: <?php                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 : /**                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 : * Smarty Internal Plugin Templateparser                                                                                                                                                                                                                                                                                                                                                                                                              
                 : *                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 : * This is the template parser.                                                                                                                                                                                                                                                                                                                                                                                                                       
                 : * It is generated from the internal.templateparser.y file                                                                                                                                                                                                                                                                                                                                                                                            
                 : * @package Smarty                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 : * @subpackage Compiler                                                                                                                                                                                                                                                                                                                                                                                                                               
                 : * @author Uwe Tews                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : */                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : /**                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :  * This can be used to store both the string representation of                                                                                                                                                                                                                                                                                                                                                                                       
                 :  * a token, and any useful meta-data associated with the token.                                                                                                                                                                                                                                                                                                                                                                                      
                 :  *                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  * meta-data should be stored as an array                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  */                                                                                                                                                                                                                                                                                                                                                                                                                                                  
               1 : class TP_yyToken implements ArrayAccess                                                                                                                                                                                                                                                                                                                                                                                                              
                 : {                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     public $string = '';                                                                                                                                                                                                                                                                                                                                                                                                                             
                 :     public $metadata = array();                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     function __construct($s, $m = array())                                                                                                                                                                                                                                                                                                                                                                                                           
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         if ($s instanceof TP_yyToken) {                                                                                                                                                                                                                                                                                                                                                                                                              
               0 :             $this->string = $s->string;                                                                                                                                                                                                                                                                                                                                                                                                              
               0 :             $this->metadata = $s->metadata;                                                                                                                                                                                                                                                                                                                                                                                                          
               0 :         } else {                                                                                                                                                                                                                                                                                                                                                                                                                                     
               0 :             $this->string = (string) $s;                                                                                                                                                                                                                                                                                                                                                                                                             
               0 :             if ($m instanceof TP_yyToken) {                                                                                                                                                                                                                                                                                                                                                                                                          
               0 :                 $this->metadata = $m->metadata;                                                                                                                                                                                                                                                                                                                                                                                                      
               0 :             } elseif (is_array($m)) {                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                 $this->metadata = $m;                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     function __toString()                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         return $this->_string;                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     function offsetExists($offset)                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         return isset($this->metadata[$offset]);                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     function offsetGet($offset)                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         return $this->metadata[$offset];                                                                                                                                                                                                                                                                                                                                                                                                             
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     function offsetSet($offset, $value)                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         if ($offset === null) {                                                                                                                                                                                                                                                                                                                                                                                                                      
               0 :             if (isset($value[0])) {                                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :                 $x = ($value instanceof TP_yyToken) ?                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                     $value->metadata : $value;                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                 $this->metadata = array_merge($this->metadata, $x);                                                                                                                                                                                                                                                                                                                                                                                  
               0 :                 return;                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :             $offset = count($this->metadata);                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :         if ($value === null) {                                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :             return;                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :         if ($value instanceof TP_yyToken) {                                                                                                                                                                                                                                                                                                                                                                                                          
               0 :             if ($value->metadata) {                                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :                 $this->metadata[$offset] = $value->metadata;                                                                                                                                                                                                                                                                                                                                                                                         
               0 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :         } elseif ($value) {                                                                                                                                                                                                                                                                                                                                                                                                                          
               0 :             $this->metadata[$offset] = $value;                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     function offsetUnset($offset)                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         unset($this->metadata[$offset]);                                                                                                                                                                                                                                                                                                                                                                                                             
               0 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 : }                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : /** The following structure represents a single element of the                                                                                                                                                                                                                                                                                                                                                                                       
                 :  * parser's stack.  Information stored includes:                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  *                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  *   +  The state number for the parser at this level of the stack.                                                                                                                                                                                                                                                                                                                                                                                  
                 :  *                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  *   +  The value of the token stored at this level of the stack.                                                                                                                                                                                                                                                                                                                                                                                    
                 :  *      (In other words, the "major" token.)                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  *                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  *   +  The semantic value stored at this level of the stack.  This is                                                                                                                                                                                                                                                                                                                                                                               
                 :  *      the information used by the action routines in the grammar.                                                                                                                                                                                                                                                                                                                                                                                  
                 :  *      It is sometimes called the "minor" token.                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  */                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 : class TP_yyStackEntry                                                                                                                                                                                                                                                                                                                                                                                                                                
               1 : {                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     public $stateno;       /* The state-number */                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     public $major;         /* The major token value.  This is the code                                                                                                                                                                                                                                                                                                                                                                               
                 :                      ** number for the token at this stack level */                                                                                                                                                                                                                                                                                                                                                                                  
                 :     public $minor; /* The user-supplied minor token value.  This                                                                                                                                                                                                                                                                                                                                                                                     
                 :                      ** is the value of the token  */                                                                                                                                                                                                                                                                                                                                                                                                
                 : };                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : // code external to the class is included here                                                                                                                                                                                                                                                                                                                                                                                                       
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : // declare_class is output here                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 12 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
                 : class Smarty_Internal_Templateparser#line 109 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                   
               1 : {                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 : /* First off, code is included which follows the "include_class" declaration                                                                                                                                                                                                                                                                                                                                                                         
                 : ** in the input file. */                                                                                                                                                                                                                                                                                                                                                                                                                             
                 : #line 14 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     // states whether the parse was successful or not                                                                                                                                                                                                                                                                                                                                                                                                
                 :     public $successful = true;                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :     public $retvalue = 0;                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     private $lex;                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     private $internalError = false;                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     function __construct($lex, $compiler) {                                                                                                                                                                                                                                                                                                                                                                                                          
                 :         // set instance object                                                                                                                                                                                                                                                                                                                                                                                                                       
             403 :         self::instance($this);                                                                                                                                                                                                                                                                                                                                                                                                                       
             403 :         $this->lex = $lex;                                                                                                                                                                                                                                                                                                                                                                                                                           
             403 :         $this->compiler = $compiler;                                                                                                                                                                                                                                                                                                                                                                                                                 
             403 :         $this->smarty = $this->compiler->smarty;                                                                                                                                                                                                                                                                                                                                                                                                     
             403 :         $this->template = $this->compiler->template;                                                                                                                                                                                                                                                                                                                                                                                                 
             403 :         if ($this->template->security && isset($this->smarty->security_handler)) {                                                                                                                                                                                                                                                                                                                                                                   
             392 :               $this->sec_obj = $this->smarty->security_policy;                                                                                                                                                                                                                                                                                                                                                                                       
             392 :         } else {                                                                                                                                                                                                                                                                                                                                                                                                                                     
              12 :               $this->sec_obj = $this->smarty;                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :         $this->cacher = $this->template->cacher_object;                                                                                                                                                                                                                                                                                                                                                                                              
             403 :         $this->compiler->has_variable_string = false;                                                                                                                                                                                                                                                                                                                                                                                                
             403 :                 $this->compiler->prefix_code = array();                                                                                                                                                                                                                                                                                                                                                                                              
             403 :                 $this->prefix_number = 0;                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :     public static function &instance($new_instance = null)                                                                                                                                                                                                                                                                                                                                                                                           
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
             403 :         static $instance = null;                                                                                                                                                                                                                                                                                                                                                                                                                     
             403 :         if (isset($new_instance) && is_object($new_instance))                                                                                                                                                                                                                                                                                                                                                                                        
             403 :             $instance = $new_instance;                                                                                                                                                                                                                                                                                                                                                                                                               
             403 :         return $instance;                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 147 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                       
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : /* Next is all token values, as class constants                                                                                                                                                                                                                                                                                                                                                                                                      
                 : */                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : /*                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : ** These constants (all generated automatically by the parser generator)                                                                                                                                                                                                                                                                                                                                                                             
                 : ** specify the various kinds of tokens (terminals) that the parser                                                                                                                                                                                                                                                                                                                                                                                   
                 : ** understands.                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : ** Each symbol here is a terminal symbol in the grammar.                                                                                                                                                                                                                                                                                                                                                                                             
                 : */                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     const TP_COMMENT                        =  1;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_PHP                            =  2;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_OTHER                          =  3;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_SHORTTAGEND                    =  4;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_SHORTTAGSTART                  =  5;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_XML                            =  6;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_LDEL                           =  7;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_RDEL                           =  8;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_DOLLAR                         =  9;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ID                             = 10;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_EQUAL                          = 11;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_FOREACH                        = 12;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_PTR                            = 13;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_IF                             = 14;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_SPACE                          = 15;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_FOR                            = 16;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_SEMICOLON                      = 17;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_INCDEC                         = 18;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_TO                             = 19;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_STEP                           = 20;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_AS                             = 21;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_APTR                           = 22;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_LDELSLASH                      = 23;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_INTEGER                        = 24;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_COMMA                          = 25;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_COLON                          = 26;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_UNIMATH                        = 27;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_OPENP                          = 28;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_CLOSEP                         = 29;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_QMARK                          = 30;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_MATH                           = 31;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ANDSYM                         = 32;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_TYPECAST                       = 33;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_DOT                            = 34;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_BOOLEAN                        = 35;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_NULL                           = 36;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_SINGLEQUOTESTRING              = 37;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_QUOTE                          = 38;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_DOUBLECOLON                    = 39;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_AT                             = 40;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_HATCH                          = 41;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_OPENB                          = 42;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_CLOSEB                         = 43;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_VERT                           = 44;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_NOT                            = 45;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISIN                           = 46;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISDIVBY                        = 47;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISNOTDIVBY                     = 48;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISEVEN                         = 49;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISNOTEVEN                      = 50;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISEVENBY                       = 51;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISNOTEVENBY                    = 52;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISODD                          = 53;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISNOTODD                       = 54;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISODDBY                        = 55;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_ISNOTODDBY                     = 56;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_INSTANCEOF                     = 57;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_EQUALS                         = 58;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_NOTEQUALS                      = 59;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_GREATERTHAN                    = 60;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_LESSTHAN                       = 61;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_GREATEREQUAL                   = 62;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_LESSEQUAL                      = 63;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_IDENTITY                       = 64;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_NONEIDENTITY                   = 65;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_MOD                            = 66;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_LAND                           = 67;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_LOR                            = 68;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_LXOR                           = 69;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_BACKTICK                       = 70;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const TP_DOLLARID                       = 71;                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const YY_NO_ACTION = 548;                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :     const YY_ACCEPT_ACTION = 547;                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     const YY_ERROR_ACTION = 546;                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 : /* Next are that tables used to determine what action to take based on the                                                                                                                                                                                                                                                                                                                                                                           
                 : ** current state and lookahead token.  These tables are used to implement                                                                                                                                                                                                                                                                                                                                                                            
                 : ** functions that take a state number and lookahead value and return an                                                                                                                                                                                                                                                                                                                                                                              
                 : ** action integer.                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : ** Suppose the action integer is N.  Then the action is determined as                                                                                                                                                                                                                                                                                                                                                                                
                 : ** follows                                                                                                                                                                                                                                                                                                                                                                                                                                           
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : **   0 <= N < self::YYNSTATE                              Shift N.  That is,                                                                                                                                                                                                                                                                                                                                                                         
                 : **                                                        push the lookahead                                                                                                                                                                                                                                                                                                                                                                         
                 : **                                                        token onto the stack                                                                                                                                                                                                                                                                                                                                                                       
                 : **                                                        and goto state N.                                                                                                                                                                                                                                                                                                                                                                          
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : **   self::YYNSTATE <= N < self::YYNSTATE+self::YYNRULE   Reduce by rule N-YYNSTATE.                                                                                                                                                                                                                                                                                                                                                                 
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : **   N == self::YYNSTATE+self::YYNRULE                    A syntax error has occurred.                                                                                                                                                                                                                                                                                                                                                               
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : **   N == self::YYNSTATE+self::YYNRULE+1                  The parser accepts its                                                                                                                                                                                                                                                                                                                                                                     
                 : **                                                        input. (and concludes parsing)                                                                                                                                                                                                                                                                                                                                                             
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : **   N == self::YYNSTATE+self::YYNRULE+2                  No such action.  Denotes unused                                                                                                                                                                                                                                                                                                                                                            
                 : **                                                        slots in the yy_action[] table.                                                                                                                                                                                                                                                                                                                                                            
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : ** The action table is constructed as a single large static array $yy_action.                                                                                                                                                                                                                                                                                                                                                                        
                 : ** Given state S and lookahead X, the action is computed as                                                                                                                                                                                                                                                                                                                                                                                          
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : **      self::$yy_action[self::$yy_shift_ofst[S] + X ]                                                                                                                                                                                                                                                                                                                                                                                               
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : ** If the index value self::$yy_shift_ofst[S]+X is out of range or if the value                                                                                                                                                                                                                                                                                                                                                                      
                 : ** self::$yy_lookahead[self::$yy_shift_ofst[S]+X] is not equal to X or if                                                                                                                                                                                                                                                                                                                                                                            
                 : ** self::$yy_shift_ofst[S] is equal to self::YY_SHIFT_USE_DFLT, it means that                                                                                                                                                                                                                                                                                                                                                                        
                 : ** the action is not in the table and that self::$yy_default[S] should be used instead.                                                                                                                                                                                                                                                                                                                                                              
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : ** The formula above is for computing the action when the lookahead is                                                                                                                                                                                                                                                                                                                                                                               
                 : ** a terminal symbol.  If the lookahead is a non-terminal (as occurs after                                                                                                                                                                                                                                                                                                                                                                           
                 : ** a reduce action) then the static $yy_reduce_ofst array is used in place of                                                                                                                                                                                                                                                                                                                                                                        
                 : ** the static $yy_shift_ofst array and self::YY_REDUCE_USE_DFLT is used in place of                                                                                                                                                                                                                                                                                                                                                                  
                 : ** self::YY_SHIFT_USE_DFLT.                                                                                                                                                                                                                                                                                                                                                                                                                          
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : ** The following are the tables generated in this section:                                                                                                                                                                                                                                                                                                                                                                                           
                 : **                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : **  self::$yy_action        A single table containing all actions.                                                                                                                                                                                                                                                                                                                                                                                   
                 : **  self::$yy_lookahead     A table containing the lookahead for each entry in                                                                                                                                                                                                                                                                                                                                                                       
                 : **                          yy_action.  Used to detect hash collisions.                                                                                                                                                                                                                                                                                                                                                                              
                 : **  self::$yy_shift_ofst    For each state, the offset into self::$yy_action for                                                                                                                                                                                                                                                                                                                                                                     
                 : **                          shifting terminals.                                                                                                                                                                                                                                                                                                                                                                                                      
                 : **  self::$yy_reduce_ofst   For each state, the offset into self::$yy_action for                                                                                                                                                                                                                                                                                                                                                                     
                 : **                          shifting non-terminals after a reduce.                                                                                                                                                                                                                                                                                                                                                                                   
                 : **  self::$yy_default       Default action for each state.                                                                                                                                                                                                                                                                                                                                                                                           
                 : */                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     const YY_SZ_ACTTAB = 1375;                                                                                                                                                                                                                                                                                                                                                                                                                       
                 : static public $yy_action = array(                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /*     0 */    15,  320,   86,   50,   23,   92,  415,  211,   24,  209,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    10 */   206,  299,   36,  415,   31,  132,  108,  230,   17,  261,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    20 */    46,    3,  547,   67,  273,  274,   62,   48,  349,  356,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    30 */   287,   49,  181,  221,   54,   13,   15,  216,   74,  185,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    40 */    91,  231,   26,  291,  229,   41,  218,  160,   23,   91,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    50 */   244,   18,  108,  230,  245,  246,   46,   12,  282,  132,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    60 */   294,  114,   62,  361,  349,  356,  287,   49,   23,  294,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    70 */    54,   13,  181,   15,   10,   84,  176,  182,  254,  132,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    80 */   291,  232,  174,  218,   53,   90,   91,  255,   24,  108,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    90 */   230,  299,   36,   46,   32,  282,  128,  150,  114,   62,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   100 */   361,  349,  356,  287,   49,  154,  294,   54,   13,  241,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   110 */    15,  306,   77,  185,  143,  292,  201,  344,  343,  207,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   120 */   341,   15,   23,  181,  310,  290,  108,  230,   58,  306,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   130 */    46,   12,  187,  132,   63,  326,   62,  108,  349,  356,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   140 */   287,   49,  310,  172,   54,   13,   91,   15,   10,   74,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   150 */   185,   84,  227,  175,  153,   24,  313,  219,  299,  339,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   160 */    91,   40,  279,  108,  230,  310,  294,   46,   32,  164,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   170 */   193,   35,  325,   62,  308,  349,  356,  287,   49,  280,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   180 */   294,   54,   13,   54,   11,    7,  329,  307,    2,    4,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   190 */   311,  305,    5,    6,  323,  181,  208,   24,  244,  169,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   200 */   299,   33,  245,  246,  300,  303,  312,  281,  346,   20,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   210 */   203,   48,   11,    7,  329,  307,    2,    4,  311,  305,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   220 */     5,    6,   15,  250,   84,  183,   24,  304,   37,  299,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   230 */    84,  125,  300,  303,  312,  181,   21,  225,  108,  230,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   240 */   355,  217,   46,   32,   68,  202,  138,  187,   62,   25,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   250 */   349,  356,  287,   49,  242,   29,   54,   13,   15,  247,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   260 */    84,  186,   54,  213,   24,  291,  184,  299,  218,  149,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   270 */   277,   91,  234,  181,  108,  230,  181,  297,   46,   32,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   280 */   282,  223,  173,  114,   62,  361,  349,  356,  287,   49,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   290 */    84,  294,   54,   13,  142,   24,  165,  231,  299,   11,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   300 */     7,  329,  307,    2,    4,  311,  305,    5,    6,   15,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   310 */    61,   74,  185,  354,   24,  309,  328,  299,  181,  300,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   320 */   303,  312,   54,  187,  327,  108,  230,  120,  220,   46,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   330 */     3,  187,  174,   24,  301,   62,  299,  349,  356,  287,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   340 */    49,  148,  306,   54,   13,  322,   30,   22,   91,  296,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   350 */   272,  274,   11,    7,  329,  307,    2,    4,  311,  305,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   360 */     5,    6,   15,  195,   74,  177,  181,   16,  294,  362,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   370 */   412,  244,  300,  303,  312,  245,  246,  187,  108,  230,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   380 */   326,  155,   46,   32,  127,  181,  174,  243,   62,  168,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   390 */   349,  356,  287,   49,   23,  324,   54,   13,   15,  306,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   400 */    74,  179,  257,  222,  199,  132,   42,  139,   75,  295,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   410 */   422,   27,  174,  289,  108,  230,  124,  181,   46,    3,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   420 */   187,  170,  306,  262,   62,   28,  349,  356,  287,   49,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   430 */   187,  306,   54,   13,  285,  286,   11,    7,  329,  307,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   440 */     2,    4,  311,  305,    5,    6,   15,  288,   84,  178,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   450 */   135,  196,  190,  269,  316,  171,  300,  303,  312,  181,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   460 */   187,  187,  108,  180,  321,  306,   15,   32,   84,  186,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   470 */    48,  187,   62,  257,  349,  356,  287,   49,  268,  271,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   480 */    54,   13,  108,  230,   39,  187,  187,   32,  181,  181,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   490 */    44,  175,   62,  250,  349,  356,  287,   49,   88,   40,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   500 */    54,   13,  259,  252,  363,  345,  338,  332,  331,  334,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   510 */   337,  275,  326,  291,  226,  181,  218,   66,  187,   91,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   520 */   123,  284,   98,  210,   15,   78,   84,  189,  282,  340,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   530 */    51,  114,  270,  361,  264,  306,  265,  240,  187,  294,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   540 */   108,  230,  147,   24,  350,   32,  299,  174,  310,   41,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   550 */    62,  107,  349,  356,  287,   49,   24,  306,   54,  188,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   560 */    15,  348,   84,  186,  317,   71,  360,  266,  133,  109,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   570 */   224,  187,  291,  302,  187,  218,  108,  230,   91,   24,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   580 */   360,   32,  228,  306,  360,  181,   62,   44,  349,  356,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   590 */   287,   49,  361,  113,   54,  181,   47,   44,  294,  259,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   600 */   252,  363,  345,  338,  332,  331,  334,  337,  360,  259,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   610 */   252,  363,  345,  338,  332,  331,  334,  337,  291,  226,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   620 */   276,  218,   66,  278,   91,  330,  134,  104,  319,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   630 */   187,   57,  187,  282,  314,  187,  114,   69,  361,  291,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   640 */   226,  187,  218,   66,  294,   91,   70,  117,  101,  350,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   650 */   163,  347,  360,  351,  282,  308,  115,  114,  187,  361,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   660 */   187,  360,  360,  291,  226,  294,  218,   66,  167,   91,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   670 */   350,  360,  100,  308,  315,  318,  144,  118,  282,  333,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   680 */   233,  114,  187,  361,  291,  226,  187,  218,   65,  294,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   690 */    91,  306,  360,   97,  350,   23,  157,  121,  236,  282,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   700 */   293,  308,  114,  119,  361,  221,  132,   38,  234,  253,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   710 */   294,  181,  306,  291,  226,  350,  218,   66,  306,   91,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   720 */   291,  226,   99,  218,   66,  358,   91,  237,  282,  102,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   730 */    16,  114,  136,  361,  238,  282,  197,   34,  114,  294,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   740 */   361,  145,  291,  298,  350,  218,  294,  306,   91,  291,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   750 */   226,  350,  218,   66,  239,   91,  306,  282,  105,  205,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   760 */   110,   76,  361,   82,  282,   85,   25,  114,  294,  361,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   770 */   291,  226,   87,  218,   66,  294,   91,  352,    1,   95,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   780 */   350,   18,   80,  214,  263,  282,  267,  200,  114,    9,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   790 */   361,  291,  226,   81,  218,   64,  294,   91,  187,  359,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   800 */    96,  350,  192,  297,   45,  137,  282,   43,   94,  114,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   810 */   325,  361,  291,  226,  204,  218,   66,  294,   91,   19,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   820 */   251,  103,  350,  212,   14,  335,   55,  282,    8,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   830 */   114,  336,  361,  297,  297,  297,  297,  297,  294,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   840 */   108,  291,  226,  350,  218,   66,  297,   91,  291,  298,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   850 */   106,  218,  129,  297,   91,  342,  282,  297,  297,  114,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   860 */   297,  361,  297,  282,  297,  297,  114,  294,  361,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   870 */   297,  215,  350,  297,  294,  297,  297,  291,  229,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   880 */   218,  160,  297,   91,  297,  297,  297,   60,  249,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   890 */   291,  298,  282,  218,  129,  114,   91,  361,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   900 */   297,  297,  297,  294,  297,  282,  297,  297,  114,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   910 */   361,  297,  256,  235,  297,  297,  294,  297,  291,   83,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   920 */   297,   73,   52,   89,   79,  291,  298,  297,  218,  129,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   930 */   297,   91,  297,  282,  297,  297,  114,  297,  361,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   940 */   282,  297,  297,  114,  294,  361,  297,  297,  283,  291,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   950 */   298,  294,  218,   56,   93,   91,  297,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   960 */   297,  297,  297,  297,  282,  297,  297,  114,  297,  361,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   970 */   297,  297,  297,  291,   83,  294,   72,   59,   89,   79,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   980 */   291,  298,  297,  218,  129,  297,   91,  297,  282,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   990 */   297,  114,  297,  361,  297,  282,  297,  297,  114,  294,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1000 */   361,  291,  298,  198,  218,  112,  294,   91,  291,  298,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1010 */   297,  218,  131,  297,   91,  297,  282,  297,  297,  114,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1020 */   297,  361,  297,  282,  297,  297,  114,  294,  361,  291,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1030 */   298,  297,  218,  151,  294,   91,  297,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1040 */   297,  297,  297,  297,  282,  297,  297,  114,  297,  361,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1050 */   291,  298,  297,  218,  152,  294,   91,  291,  298,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1060 */   218,  130,  297,   91,  297,  282,  297,  297,  114,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1070 */   361,  297,  282,  297,  297,  114,  294,  361,  291,  298,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1080 */   297,  218,  161,  294,   91,  291,  298,  297,  218,  146,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1090 */   297,   91,  297,  282,  297,  297,  114,  297,  361,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1100 */   282,  297,  297,  114,  294,  361,  291,  298,  297,  218,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1110 */   156,  294,   91,  297,  297,  297,  297,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1120 */   297,  282,  297,  297,  114,  297,  361,  291,  298,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1130 */   218,  122,  294,   91,  291,  298,  297,  218,  162,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1140 */    91,  297,  282,  297,  297,  114,  297,  361,  297,  282,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1150 */   297,  297,  114,  294,  361,  291,  298,  297,  218,  166,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1160 */   294,   91,  291,  298,  297,  218,  126,  297,   91,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1170 */   282,  297,  297,  114,  297,  361,  297,  282,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1180 */   114,  294,  361,  291,  298,  297,  218,  141,  294,   91,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1190 */   297,  297,  297,  297,  297,  297,  297,  297,  282,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1200 */   297,  114,  297,  361,  291,  298,  297,  218,  158,  294,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1210 */    91,  291,  298,  297,  218,  159,  297,   91,  297,  282,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1220 */   297,  297,  114,  297,  361,  297,  282,  297,  297,  114,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1230 */   294,  361,  291,  298,  297,  218,  140,  294,   91,  291,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1240 */   298,  297,  218,  297,  297,   91,  297,  282,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1250 */   114,  297,  361,  297,  282,  297,  297,  111,  294,  361,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1260 */   291,  298,  297,  218,  297,  294,   91,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1270 */   297,  297,  297,  297,  297,  282,  297,  297,  116,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1280 */   361,  291,  191,  297,  218,  297,  294,   91,  291,  260,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1290 */   297,  218,  291,  353,   91,  218,  194,  297,   91,  291,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1300 */   357,  361,  218,  258,  297,   91,  251,  294,  361,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1310 */    14,  297,  361,  297,  294,  297,  297,  297,  294,  361,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1320 */   297,  297,  297,  297,  297,  294,  108,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1330 */   297,  297,  297,  297,  297,  297,  297,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1340 */   297,  248,  297,  297,  297,  297,  297,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1350 */   297,  297,  297,  297,  297,  297,  297,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1360 */   297,  297,  297,  297,  297,  297,  297,  297,  297,  297,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1370 */   297,  297,  297,   60,  249,                                                                                                                                                                                                                                                                                                                                                                                                          
                 :     );                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :     static public $yy_lookahead = array(                                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*     0 */     7,  105,    9,   10,   28,   12,    8,   14,    7,   16,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    10 */    34,   10,   11,   15,   26,   39,   23,   24,   11,   43,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    20 */    27,   28,   73,   74,   75,   76,   33,   13,   35,   36,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    30 */    37,   38,   44,   26,   41,   42,    7,   79,    9,   10,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    40 */    82,   40,   22,   76,   77,   26,   79,   80,   28,   82,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    50 */    27,   11,   23,   24,   31,   32,   27,   28,   91,   39,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    60 */   102,   94,   33,   96,   35,   36,   37,   38,   28,  102,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    70 */    41,   42,   44,    7,   45,    9,   10,  110,  111,   39,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    80 */    76,   77,   83,   79,   80,   81,   82,    8,    7,   23,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    90 */    24,   10,   11,   27,   28,   91,   78,   17,   94,   33,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   100 */    96,   35,   36,   37,   38,   25,  102,   41,   42,   43,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   110 */     7,   93,    9,   10,   78,    1,    2,    3,    4,    5,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   120 */     6,    7,   28,   44,  106,    8,   23,   24,   84,   93,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   130 */    27,   28,   15,   39,   84,   18,   33,   23,   35,   36,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   140 */    37,   38,  106,   79,   41,   42,   82,    7,   45,    9,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   150 */    10,    9,   10,   34,   17,    7,    8,   79,   10,    8,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   160 */    82,   42,   98,   23,   24,  106,  102,   27,   28,  100,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   170 */    22,   20,  103,   33,  105,   35,   36,   37,   38,    8,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   180 */   102,   41,   42,   41,   47,   48,   49,   50,   51,   52,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   190 */    53,   54,   55,   56,   29,   44,   10,    7,   27,    8,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   200 */    10,   11,   31,   32,   67,   68,   69,   10,   18,   11,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   210 */    24,   13,   47,   48,   49,   50,   51,   52,   53,   54,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   220 */    55,   56,    7,   76,    9,   10,    7,    8,    7,   10,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   230 */     9,   10,   67,   68,   69,   44,   25,   40,   23,   24,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   240 */     8,   22,   27,   28,   97,   13,  101,   15,   33,   11,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   250 */    35,   36,   37,   38,   43,   26,   41,   42,    7,  112,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   260 */     9,   10,   41,   90,    7,   76,   77,   10,   79,   80,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   270 */    81,   82,   34,   44,   23,   24,   44,  104,   27,   28,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   280 */    91,   29,    8,   94,   33,   96,   35,   36,   37,   38,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   290 */     9,  102,   41,   42,  101,    7,   84,   40,   10,   47,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   300 */    48,   49,   50,   51,   52,   53,   54,   55,   56,    7,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   310 */    84,    9,   10,    8,    7,    8,    8,   10,   44,   67,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   320 */    68,   69,   41,   15,    8,   23,   24,   78,   40,   27,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   330 */    28,   15,   83,    7,    8,   33,   10,   35,   36,   37,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   340 */    38,  101,   93,   41,   42,   79,    7,   25,   82,    8,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   350 */    75,   76,   47,   48,   49,   50,   51,   52,   53,   54,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   360 */    55,   56,    7,   21,    9,   10,   44,   28,  102,   10,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   370 */     8,   27,   67,   68,   69,   31,   32,   15,   23,   24,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   380 */    18,   10,   27,   28,   78,   44,   83,   43,   33,   83,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   390 */    35,   36,   37,   38,   28,   10,   41,   42,    7,   93,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   400 */     9,   10,   29,    9,   10,   39,    7,   78,    9,   10,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   410 */    44,  108,   83,    8,   23,   24,   78,   44,   27,   28,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   420 */    15,   83,   93,   24,   33,   30,   35,   36,   37,   38,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   430 */    15,   93,   41,   42,   35,   36,   47,   48,   49,   50,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   440 */    51,   52,   53,   54,   55,   56,    7,   41,    9,   10,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   450 */    78,   86,   87,    8,    8,   83,   67,   68,   69,   44,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   460 */    15,   15,   23,   24,    8,   93,    7,   28,    9,   10,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   470 */    13,   15,   33,   29,   35,   36,   37,   38,    8,    8,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   480 */    41,   42,   23,   24,   30,   15,   15,   28,   44,   44,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   490 */    46,   34,   33,   76,   35,   36,   37,   38,   29,   42,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   500 */    41,   42,   58,   59,   60,   61,   62,   63,   64,   65,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   510 */    66,    8,   18,   76,   77,   44,   79,   80,   15,   82,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   520 */    78,   70,   85,   86,    7,    9,    9,   10,   91,  112,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   530 */    10,   94,   12,   96,   14,   93,   16,   10,   15,  102,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   540 */    23,   24,   78,    7,  107,   28,   10,   83,  106,   26,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   550 */    33,   89,   35,   36,   37,   38,    7,   93,   41,   10,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   560 */     7,   24,    9,   10,    8,   89,  104,    8,   78,   89,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   570 */    29,   15,   76,   77,   15,   79,   23,   24,   82,    7,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   580 */   104,   28,   10,   93,  104,   44,   33,   46,   35,   36,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   590 */    37,   38,   96,   89,   41,   44,   57,   46,  102,   58,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   600 */    59,   60,   61,   62,   63,   64,   65,   66,  104,   58,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   610 */    59,   60,   61,   62,   63,   64,   65,   66,   76,   77,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   620 */     8,   79,   80,    8,   82,    8,  101,   85,    8,  104,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   630 */    15,   10,   15,   91,    8,   15,   94,   89,   96,   76,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   640 */    77,   15,   79,   80,  102,   82,   89,   89,   85,  107,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   650 */   100,    8,  104,    8,   91,  105,   89,   94,   15,   96,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   660 */    15,  104,  104,   76,   77,  102,   79,   80,  100,   82,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   670 */   107,  104,   85,  105,   10,    8,   78,   89,   91,    8,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   680 */    13,   94,   15,   96,   76,   77,   15,   79,   80,  102,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   690 */    82,   93,  104,   85,  107,   28,  100,   78,   29,   91,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   700 */    41,  105,   94,   78,   96,   26,   39,   22,   34,    4,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   710 */   102,   44,   93,   76,   77,  107,   79,   80,   93,   82,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   720 */    76,   77,   85,   79,   80,    8,   82,   29,   91,   85,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   730 */    28,   94,   78,   96,   43,   91,    3,   19,   94,  102,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   740 */    96,   78,   76,   77,  107,   79,  102,   93,   82,   76,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   750 */    77,  107,   79,   80,    4,   82,   93,   91,   85,   10,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   760 */    94,    9,   96,    9,   91,    9,   11,   94,  102,   96,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   770 */    76,   77,   15,   79,   80,  102,   82,    8,   15,   85,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   780 */   107,   11,    9,    3,    8,   91,    8,   10,   94,  109,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   790 */    96,   76,   77,    9,   79,   80,  102,   82,   15,   93,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   800 */    85,  107,   21,  104,   95,  101,   91,   15,   98,   94,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   810 */   103,   96,   76,   77,   92,   79,   80,  102,   82,   28,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   820 */     3,   85,  107,   88,    7,   86,  101,   91,   88,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   830 */    94,   15,   96,  113,  113,  113,  113,  113,  102,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   840 */    23,   76,   77,  107,   79,   80,  113,   82,   76,   77,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   850 */    85,   79,   80,  113,   82,   38,   91,  113,  113,   94,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   860 */   113,   96,  113,   91,  113,  113,   94,  102,   96,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   870 */   113,   99,  107,  113,  102,  113,  113,   76,   77,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   880 */    79,   80,  113,   82,  113,  113,  113,   70,   71,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   890 */    76,   77,   91,   79,   80,   94,   82,   96,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   900 */   113,  113,  113,  102,  113,   91,  113,  113,   94,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   910 */    96,  113,  111,   99,  113,  113,  102,  113,   76,   77,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   920 */   113,   79,   80,   81,   82,   76,   77,  113,   79,   80,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   930 */   113,   82,  113,   91,  113,  113,   94,  113,   96,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   940 */    91,  113,  113,   94,  102,   96,  113,  113,   99,   76,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   950 */    77,  102,   79,   80,   81,   82,  113,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   960 */   113,  113,  113,  113,   91,  113,  113,   94,  113,   96,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   970 */   113,  113,  113,   76,   77,  102,   79,   80,   81,   82,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   980 */    76,   77,  113,   79,   80,  113,   82,  113,   91,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   990 */   113,   94,  113,   96,  113,   91,  113,  113,   94,  102,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1000 */    96,   76,   77,   99,   79,   80,  102,   82,   76,   77,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1010 */   113,   79,   80,  113,   82,  113,   91,  113,  113,   94,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1020 */   113,   96,  113,   91,  113,  113,   94,  102,   96,   76,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1030 */    77,  113,   79,   80,  102,   82,  113,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1040 */   113,  113,  113,  113,   91,  113,  113,   94,  113,   96,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1050 */    76,   77,  113,   79,   80,  102,   82,   76,   77,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1060 */    79,   80,  113,   82,  113,   91,  113,  113,   94,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1070 */    96,  113,   91,  113,  113,   94,  102,   96,   76,   77,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1080 */   113,   79,   80,  102,   82,   76,   77,  113,   79,   80,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1090 */   113,   82,  113,   91,  113,  113,   94,  113,   96,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1100 */    91,  113,  113,   94,  102,   96,   76,   77,  113,   79,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1110 */    80,  102,   82,  113,  113,  113,  113,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1120 */   113,   91,  113,  113,   94,  113,   96,   76,   77,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1130 */    79,   80,  102,   82,   76,   77,  113,   79,   80,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1140 */    82,  113,   91,  113,  113,   94,  113,   96,  113,   91,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1150 */   113,  113,   94,  102,   96,   76,   77,  113,   79,   80,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1160 */   102,   82,   76,   77,  113,   79,   80,  113,   82,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1170 */    91,  113,  113,   94,  113,   96,  113,   91,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1180 */    94,  102,   96,   76,   77,  113,   79,   80,  102,   82,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1190 */   113,  113,  113,  113,  113,  113,  113,  113,   91,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1200 */   113,   94,  113,   96,   76,   77,  113,   79,   80,  102,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1210 */    82,   76,   77,  113,   79,   80,  113,   82,  113,   91,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1220 */   113,  113,   94,  113,   96,  113,   91,  113,  113,   94,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1230 */   102,   96,   76,   77,  113,   79,   80,  102,   82,   76,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1240 */    77,  113,   79,  113,  113,   82,  113,   91,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1250 */    94,  113,   96,  113,   91,  113,  113,   94,  102,   96,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1260 */    76,   77,  113,   79,  113,  102,   82,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1270 */   113,  113,  113,  113,  113,   91,  113,  113,   94,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1280 */    96,   76,   77,  113,   79,  113,  102,   82,   76,   77,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1290 */   113,   79,   76,   77,   82,   79,   91,  113,   82,   76,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1300 */    77,   96,   79,   91,  113,   82,    3,  102,   96,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1310 */     7,  113,   96,  113,  102,  113,  113,  113,  102,   96,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1320 */   113,  113,  113,  113,  113,  102,   23,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1330 */   113,  113,  113,  113,  113,  113,  113,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1340 */   113,   38,  113,  113,  113,  113,  113,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1350 */   113,  113,  113,  113,  113,  113,  113,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1360 */   113,  113,  113,  113,  113,  113,  113,  113,  113,  113,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  1370 */   113,  113,  113,   70,   71,                                                                                                                                                                                                                                                                                                                                                                                                          
                 : );                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     const YY_SHIFT_USE_DFLT = -25;                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     const YY_SHIFT_MAX = 235;                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :     static public $yy_shift_ofst = array(                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*     0 */   114,  103,   29,   29,   29,   29,   29,   29,   29,   29,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    10 */    29,   29,   29,  355,   -7,   -7,  140,  302,  391,  140,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    20 */   302,  355,  140,  140,  140,  140,  140,  140,  140,  140,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    30 */   140,  140,  140,  140,  140,  140,  140,  140,  140,  140,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    40 */    66,  215,  251,  439,  459,  553,  553,  517,  221, 1303,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    50 */   667,  232,  445,  471,  142,  457,  415,  415,  523,  415,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    60 */   281,  523,  281,  523,  444,  541,  551,  114,  817,  190,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    70 */     1,  257,  362,  117,  572,  536,  536,  572,  536,  198,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    80 */   536,  536,  536,  671,  536,  536,  549,  784,   14,  783,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    90 */   783,   14,  792,  783,   14,  137,  165,  252,  305,  389,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   100 */   389,  389,  389,  389,  389,  389,  389,  148,  520,  219,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   110 */   171,  344,  151,  288,   23,   81,   23,  326,  307,  308,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   120 */   316,  446,   79,  456,  645,  339,  229,  620,  617,  322,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   130 */   341,  373,  394,  643,  119,  626,  405,  119,  119,  615,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   140 */   -12,  274,  119,  556,  470,  503,  191,  559,  119,   28,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   150 */   816,   28,   28,  816,  784,  791,   28,   14,   28,   28,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   160 */    28,   28,   28,   14,   14,   19,   28,   14,  -25,  -25,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   170 */   -25,  -25,  -25,  -25,  -25,  399,  -24,   20,   40,  366,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   180 */   238,  197,  211,   94,   -2,   94,   94,  186,    7,   94,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   190 */    80,  781,  752,  754,  342,  756,  718,  750,  698,  702,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   200 */   691,  733,  749,  755,  776,  778,  777,  780,  770,  757,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   210 */   769,  763,  773,  717,  705,  469,  451,  516,  494,  406,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   220 */   385,  359,  371,  395,  454,  527,  539,  659,  679,  685,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   230 */   674,  664,  612,  621,  537,  669,                                                                                                                                                                                                                                                                                                                                                                                                    
                 : );                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     const YY_REDUCE_USE_DFLT = -105;                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :     const YY_REDUCE_MAX = 174;                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :     static public $yy_reduce_ofst = array(                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /*     0 */   -51,  437,  637,  608,  563,  644,  542,  587,  694,  736,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    10 */   765,  673,  715,  -33,  842,  897,  904,    4,  189,  772,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    20 */   873,  801,  849,  814, 1051, 1058, 1128, 1079, 1086, 1030,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    30 */  1009,  953,  932,  974,  925,  981, 1002, 1107, 1135, 1156,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    40 */  1163, 1184,  666, 1205, 1212, 1216,  496, 1223,   64,  147,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    50 */   372,  338,  329,  464,   78,   69,  249,  306,   36,  329,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    60 */   -42,   18,  266,  442,  303,  303,  303,  275,  417,  173,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    70 */   525,  525,  654,  654,  476,  504,  462,  557,  588,  550,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    80 */   548,  567,  558,  490,  476,  480,  476,  365,  596,  663,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    90 */   598,  550,  625,  619,  568,  680,  680,  680,  680,  680,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   100 */   680,  680,  680,  680,  680,  680,  680,  699,  722,  699,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   110 */   709,  709,   -1,  699,  709,  699,  709,  699,  699,  706,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   120 */   706,  706,   -1,  706,  706,  704,   -1,  706,  706,   -1,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   130 */    -1,   -1,  710,  706,  707,  706,  706,  707,  707,  706,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   140 */    -1,   -1,  707,  706,  706,  706,   -1,  706,  707,   -1,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   150 */   740,   -1,   -1,  735,  739,  725,   -1, -104,   -1,   -1,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   160 */    -1,   -1,   -1, -104, -104,   59,   -1, -104,   44,  240,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   170 */   226,   50,  145,  193,  212,                                                                                                                                                                                                                                                                                                                                                                                                          
                 : );                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     static public $yyExpectedTokens = array(                                                                                                                                                                                                                                                                                                                                                                                                         
                 :         /* 0 */ array(1, 2, 3, 4, 5, 6, 7, 23, ),                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 1 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 2 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 3 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 4 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 5 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 6 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 7 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 8 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 9 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 10 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                  
                 :         /* 11 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                  
                 :         /* 12 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 45, ),                                                                                                                                                                                                                                                                                                                                                                  
                 :         /* 13 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 14 */ array(7, 9, 10, 12, 14, 16, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                          
                 :         /* 15 */ array(7, 9, 10, 12, 14, 16, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                          
                 :         /* 16 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 17 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 18 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 19 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 20 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 21 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 22 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 23 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 24 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 25 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 26 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 27 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 28 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 29 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 30 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 31 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 32 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 33 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 34 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 35 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 36 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 37 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 38 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 39 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 40 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, 43, ),                                                                                                                                                                                                                                                                                                                                                                  
                 :         /* 41 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 42 */ array(7, 9, 10, 23, 24, 27, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 43 */ array(7, 9, 10, 23, 24, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                          
                 :         /* 44 */ array(7, 9, 10, 23, 24, 28, 33, 35, 36, 37, 38, 41, 42, ),                                                                                                                                                                                                                                                                                                                                                                          
                 :         /* 45 */ array(7, 9, 10, 23, 24, 28, 33, 35, 36, 37, 38, 41, ),                                                                                                                                                                                                                                                                                                                                                                              
                 :         /* 46 */ array(7, 9, 10, 23, 24, 28, 33, 35, 36, 37, 38, 41, ),                                                                                                                                                                                                                                                                                                                                                                              
                 :         /* 47 */ array(7, 9, 10, 23, 24, 28, 33, 35, 36, 37, 38, 41, ),                                                                                                                                                                                                                                                                                                                                                                              
                 :         /* 48 */ array(7, 9, 10, 41, ),                                                                                                                                                                                                                                                                                                                                                                                                              
                 :         /* 49 */ array(3, 7, 23, 38, 70, 71, ),                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 50 */ array(8, 13, 15, 28, 39, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 51 */ array(8, 13, 15, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                             
                 :         /* 52 */ array(8, 15, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :         /* 53 */ array(8, 15, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :         /* 54 */ array(9, 10, 41, ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :         /* 55 */ array(13, 34, 42, ),                                                                                                                                                                                                                                                                                                                                                                                                                
                 :         /* 56 */ array(15, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 57 */ array(15, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 58 */ array(15, 26, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 59 */ array(15, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 60 */ array(9, 41, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 61 */ array(15, 26, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 62 */ array(9, 41, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 63 */ array(15, 26, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 64 */ array(29, 44, 46, 58, 59, 60, 61, 62, 63, 64, 65, 66, ),                                                                                                                                                                                                                                                                                                                                                                            
                 :         /* 65 */ array(29, 44, 46, 58, 59, 60, 61, 62, 63, 64, 65, 66, ),                                                                                                                                                                                                                                                                                                                                                                            
                 :         /* 66 */ array(44, 46, 58, 59, 60, 61, 62, 63, 64, 65, 66, ),                                                                                                                                                                                                                                                                                                                                                                                
                 :         /* 67 */ array(1, 2, 3, 4, 5, 6, 7, 23, ),                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 68 */ array(3, 7, 23, 38, 70, 71, ),                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* 69 */ array(7, 10, 11, 18, ),                                                                                                                                                                                                                                                                                                                                                                                                             
                 :         /* 70 */ array(7, 10, 11, 40, ),                                                                                                                                                                                                                                                                                                                                                                                                             
                 :         /* 71 */ array(7, 10, 40, ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :         /* 72 */ array(8, 15, 18, ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :         /* 73 */ array(8, 15, 18, ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :         /* 74 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 75 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 76 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 77 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 78 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 79 */ array(11, 13, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 80 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 81 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 82 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 83 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 84 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 85 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 86 */ array(7, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 87 */ array(9, ),                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :         /* 88 */ array(13, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 89 */ array(15, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 90 */ array(15, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 91 */ array(13, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 92 */ array(15, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 93 */ array(15, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 94 */ array(13, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 95 */ array(17, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 96 */ array(29, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 97 */ array(29, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 98 */ array(8, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 99 */ array(47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 100 */ array(47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 101 */ array(47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 102 */ array(47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 103 */ array(47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 104 */ array(47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 105 */ array(47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 106 */ array(47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 67, 68, 69, ),                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 107 */ array(7, 8, 10, 22, ),                                                                                                                                                                                                                                                                                                                                                                                                             
                 :         /* 108 */ array(10, 12, 14, 16, ),                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 109 */ array(7, 8, 10, 22, ),                                                                                                                                                                                                                                                                                                                                                                                                             
                 :         /* 110 */ array(8, 27, 31, 32, ),                                                                                                                                                                                                                                                                                                                                                                                                            
                 :         /* 111 */ array(27, 31, 32, 43, ),                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 112 */ array(8, 20, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                
                 :         /* 113 */ array(7, 10, 40, ),                                                                                                                                                                                                                                                                                                                                                                                                                
                 :         /* 114 */ array(27, 31, 32, ),                                                                                                                                                                                                                                                                                                                                                                                                               
                 :         /* 115 */ array(7, 10, 11, ),                                                                                                                                                                                                                                                                                                                                                                                                                
                 :         /* 116 */ array(27, 31, 32, ),                                                                                                                                                                                                                                                                                                                                                                                                               
                 :         /* 117 */ array(7, 8, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :         /* 118 */ array(7, 8, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :         /* 119 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 120 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 121 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 122 */ array(8, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 123 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 124 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 125 */ array(7, 28, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 126 */ array(26, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 127 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 128 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 129 */ array(25, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 130 */ array(8, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 131 */ array(29, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 132 */ array(9, 10, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 133 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 134 */ array(34, 42, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 135 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 136 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 137 */ array(34, 42, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 138 */ array(34, 42, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 139 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 140 */ array(26, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 141 */ array(8, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 142 */ array(34, 42, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 143 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 144 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 145 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 146 */ array(8, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 147 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 148 */ array(34, 42, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 149 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 150 */ array(15, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 151 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 152 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 153 */ array(15, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 154 */ array(9, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 155 */ array(28, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 156 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 157 */ array(13, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 158 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 159 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 160 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 161 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 162 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 163 */ array(13, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 164 */ array(13, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 165 */ array(26, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 166 */ array(44, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 167 */ array(13, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 168 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 169 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 170 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 171 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 172 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 173 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 174 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 175 */ array(7, 9, 10, 24, 35, 36, ),                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         /* 176 */ array(28, 34, 39, 43, ),                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 177 */ array(22, 28, 39, ),                                                                                                                                                                                                                                                                                                                                                                                                               
                 :         /* 178 */ array(11, 28, 39, ),                                                                                                                                                                                                                                                                                                                                                                                                               
                 :         /* 179 */ array(28, 39, 44, ),                                                                                                                                                                                                                                                                                                                                                                                                               
                 :         /* 180 */ array(11, 34, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 181 */ array(10, 40, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 182 */ array(25, 43, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 183 */ array(28, 39, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 184 */ array(8, 15, ),                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         /* 185 */ array(28, 39, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 186 */ array(28, 39, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 187 */ array(10, 24, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 188 */ array(11, 26, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 189 */ array(28, 39, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 190 */ array(17, 25, ),                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         /* 191 */ array(21, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 192 */ array(9, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 193 */ array(9, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 194 */ array(21, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 195 */ array(9, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 196 */ array(19, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 197 */ array(4, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 198 */ array(29, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 199 */ array(28, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 200 */ array(43, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 201 */ array(3, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 202 */ array(10, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 203 */ array(11, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 204 */ array(8, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 205 */ array(8, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 206 */ array(10, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 207 */ array(3, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 208 */ array(11, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 209 */ array(15, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 210 */ array(8, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 211 */ array(15, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 212 */ array(9, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 213 */ array(8, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 214 */ array(4, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 215 */ array(29, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 216 */ array(70, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 217 */ array(9, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 218 */ array(18, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 219 */ array(41, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 220 */ array(10, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 221 */ array(10, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 222 */ array(10, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 223 */ array(30, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 224 */ array(30, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 225 */ array(10, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 226 */ array(57, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 227 */ array(41, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 228 */ array(26, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 229 */ array(22, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 230 */ array(34, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 231 */ array(10, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 232 */ array(8, ),                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         /* 233 */ array(10, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 234 */ array(24, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 235 */ array(29, ),                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         /* 236 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 237 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 238 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 239 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 240 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 241 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 242 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 243 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 244 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 245 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 246 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 247 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 248 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 249 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 250 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 251 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 252 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 253 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 254 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 255 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 256 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 257 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 258 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 259 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 260 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 261 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 262 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 263 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 264 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 265 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 266 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 267 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 268 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 269 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 270 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 271 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 272 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 273 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 274 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 275 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 276 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 277 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 278 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 279 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 280 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 281 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 282 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 283 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 284 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 285 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 286 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 287 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 288 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 289 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 290 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 291 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 292 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 293 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 294 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 295 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 296 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 297 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 298 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 299 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 300 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 301 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 302 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 303 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 304 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 305 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 306 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 307 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 308 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 309 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 310 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 311 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 312 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 313 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 314 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 315 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 316 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 317 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 318 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 319 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 320 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 321 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 322 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 323 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 324 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 325 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 326 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 327 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 328 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 329 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 330 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 331 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 332 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 333 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 334 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 335 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 336 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 337 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 338 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 339 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 340 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 341 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 342 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 343 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 344 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 345 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 346 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 347 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 348 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 349 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 350 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 351 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 352 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 353 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 354 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 355 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 356 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 357 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 358 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 359 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 360 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 361 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 362 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         /* 363 */ array(),                                                                                                                                                                                                                                                                                                                                                                                                                           
                 : );                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     static public $yy_default = array(                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*     0 */   546,  546,  546,  546,  546,  546,  546,  546,  546,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    10 */   546,  546,  546,  532,  546,  546,  490,  546,  546,  490,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    20 */   546,  546,  490,  490,  546,  546,  546,  546,  546,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    30 */   546,  546,  546,  546,  546,  546,  546,  546,  546,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    40 */   546,  546,  546,  546,  546,  546,  546,  546,  546,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    50 */   546,  546,  546,  546,  546,  452,  412,  412,  412,  412,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    60 */   546,  412,  546,  412,  500,  500,  500,  364,  546,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    70 */   462,  462,  435,  435,  546,  546,  546,  546,  546,  455,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    80 */   546,  546,  546,  426,  546,  546,  546,  546,  448,  412,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*    90 */   412,  455,  412,  412,  447,  546,  546,  546,  546,  509,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   100 */   506,  510,  513,  504,  514,  505,  498,  546,  546,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   110 */   546,  546,  546,  463,  423,  546,  495,  546,  546,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   120 */   546,  546,  546,  546,  546,  462,  546,  546,  546,  489,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   130 */   546,  546,  546,  546,  460,  546,  546,  481,  482,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   140 */   546,  546,  483,  546,  546,  546,  546,  546,  484,  414,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   150 */   545,  431,  394,  545,  546,  462,  430,  450,  534,  533,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   160 */   535,  421,  418,  478,  453,  425,  501,  449,  494,  462,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   170 */   494,  494,  462,  462,  494,  546,  546,  422,  417,  413,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   180 */   438,  546,  546,  496,  426,  422,  546,  546,  476,  515,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   190 */   546,  546,  546,  546,  546,  546,  419,  546,  546,  451,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   200 */   546,  546,  546,  546,  546,  546,  546,  546,  417,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   210 */   546,  546,  546,  546,  546,  546,  546,  546,  435,  546,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   220 */   546,  546,  546,  546,  443,  546,  426,  546,  476,  426,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   230 */   438,  546,  426,  546,  546,  546,  486,  487,  471,  369,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   240 */   491,  473,  529,  472,  432,  433,  434,  537,  446,  539,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   250 */   542,  543,  518,  370,  530,  477,  531,  443,  502,  517,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   260 */   503,  470,  468,  403,  404,  405,  381,  409,  382,  541,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   270 */   406,  380,  366,  365,  367,  378,  379,  416,  377,  485,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   280 */   469,  492,  429,  488,  538,  466,  467,  444,  459,  376,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   290 */   540,  454,  368,  458,  457,  465,  397,  475,  426,  476,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   300 */   526,  399,  427,  527,  400,  512,  411,  508,  479,  401,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   310 */   493,  511,  528,  398,  385,  456,  384,  390,  387,  388,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   320 */   480,  389,  436,  499,  464,  461,  437,  383,  386,  507,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   330 */   408,  523,  522,  374,  524,  420,  544,  525,  521,  396,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   340 */   536,  371,  445,  372,  373,  520,  395,  375,  439,  440,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   350 */   497,  407,  392,  428,  391,  402,  441,  516,  393,  410,                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*   360 */   474,  442,  424,  519,                                                                                                                                                                                                                                                                                                                                                                                                                
                 : );                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : /* The next thing included is series of defines which control                                                                                                                                                                                                                                                                                                                                                                                        
                 : ** various aspects of the generated parser.                                                                                                                                                                                                                                                                                                                                                                                                          
                 : **    self::YYNOCODE      is a number which corresponds                                                                                                                                                                                                                                                                                                                                                                                              
                 : **                        to no legal terminal or nonterminal number.  This                                                                                                                                                                                                                                                                                                                                                                          
                 : **                        number is used to fill in empty slots of the hash                                                                                                                                                                                                                                                                                                                                                                          
                 : **                        table.                                                                                                                                                                                                                                                                                                                                                                                                                     
                 : **    self::YYFALLBACK    If defined, this indicates that one or more tokens                                                                                                                                                                                                                                                                                                                                                                         
                 : **                        have fall-back values which should be used if the                                                                                                                                                                                                                                                                                                                                                                          
                 : **                        original value of the token will not parse.                                                                                                                                                                                                                                                                                                                                                                                
                 : **    self::YYSTACKDEPTH  is the maximum depth of the parser's stack.                                                                                                                                                                                                                                                                                                                                                                                
                 : **    self::YYNSTATE      the combined number of states.                                                                                                                                                                                                                                                                                                                                                                                             
                 : **    self::YYNRULE       the number of rules in the grammar                                                                                                                                                                                                                                                                                                                                                                                         
                 : **    self::YYERRORSYMBOL is the code number of the error symbol.  If not                                                                                                                                                                                                                                                                                                                                                                            
                 : **                        defined, then do no error processing.                                                                                                                                                                                                                                                                                                                                                                                      
                 : */                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     const YYNOCODE = 114;                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     const YYSTACKDEPTH = 100;                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :     const YYNSTATE = 364;                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     const YYNRULE = 182;                                                                                                                                                                                                                                                                                                                                                                                                                             
                 :     const YYERRORSYMBOL = 72;                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :     const YYERRSYMDT = 'yy0';                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :     const YYFALLBACK = 0;                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     /** The next table maps tokens into fallback tokens.  If a construct                                                                                                                                                                                                                                                                                                                                                                             
                 :      * like the following:                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      *      %fallback ID X Y Z.                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * appears in the grammer, then ID becomes a fallback token for X, Y,                                                                                                                                                                                                                                                                                                                                                                            
                 :      * and Z.  Whenever one of the tokens X, Y, or Z is input to the parser                                                                                                                                                                                                                                                                                                                                                                          
                 :      * but it does not parse, the type of the token is changed to ID and                                                                                                                                                                                                                                                                                                                                                                             
                 :      * the parse is retried before an error is thrown.                                                                                                                                                                                                                                                                                                                                                                                               
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static public $yyFallback = array(                                                                                                                                                                                                                                                                                                                                                                                                               
                 :     );                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Turn parser tracing on by giving a stream to which to write the trace                                                                                                                                                                                                                                                                                                                                                                         
                 :      * and a prompt to preface each trace message.  Tracing is turned off                                                                                                                                                                                                                                                                                                                                                                            
                 :      * by making either argument NULL                                                                                                                                                                                                                                                                                                                                                                                                                
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * Inputs:                                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * - A stream resource to which trace output should be written.                                                                                                                                                                                                                                                                                                                                                                                  
                 :      *   If NULL, then tracing is turned off.                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      * - A prefix string written at the beginning of every                                                                                                                                                                                                                                                                                                                                                                                           
                 :      *   line of trace output.  If NULL, then tracing is                                                                                                                                                                                                                                                                                                                                                                                             
                 :      *   turned off.                                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * Outputs:                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * - None.                                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :      * @param resource                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * @param string                                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static function Trace($TraceFILE, $zTracePrompt)                                                                                                                                                                                                                                                                                                                                                                                                 
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         if (!$TraceFILE) {                                                                                                                                                                                                                                                                                                                                                                                                                           
               0 :             $zTracePrompt = 0;                                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :         } elseif (!$zTracePrompt) {                                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :             $TraceFILE = 0;                                                                                                                                                                                                                                                                                                                                                                                                                          
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :         self::$yyTraceFILE = $TraceFILE;                                                                                                                                                                                                                                                                                                                                                                                                             
               0 :         self::$yyTracePrompt = $zTracePrompt;                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Output debug information to output (php://output stream)                                                                                                                                                                                                                                                                                                                                                                                      
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static function PrintTrace()                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         self::$yyTraceFILE = fopen('php://output', 'w');                                                                                                                                                                                                                                                                                                                                                                                             
               0 :         self::$yyTracePrompt = '<br>';                                                                                                                                                                                                                                                                                                                                                                                                               
               0 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * @var resource|0                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static public $yyTraceFILE;                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * String to prepend to debug output                                                                                                                                                                                                                                                                                                                                                                                                             
                 :      * @var string|0                                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static public $yyTracePrompt;                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * @var int                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     public $yyidx;                    /* Index of top element in stack */                                                                                                                                                                                                                                                                                                                                                                            
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * @var int                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     public $yyerrcnt;                 /* Shifts left before out of the error */                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * @var array                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     public $yystack = array();  /* The parser's stack */                                                                                                                                                                                                                                                                                                                                                                                             
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * For tracing shifts, the names of all terminals and nonterminals                                                                                                                                                                                                                                                                                                                                                                               
                 :      * are required.  The following table supplies these names                                                                                                                                                                                                                                                                                                                                                                                       
                 :      * @var array                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     public $yyTokenName = array(                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :   '$',             'COMMENT',       'PHP',           'OTHER',                                                                                                                                                                                                                                                                                                                                                                                        
                 :   'SHORTTAGEND',   'SHORTTAGSTART',  'XML',           'LDEL',                                                                                                                                                                                                                                                                                                                                                                                        
                 :   'RDEL',          'DOLLAR',        'ID',            'EQUAL',                                                                                                                                                                                                                                                                                                                                                                                        
                 :   'FOREACH',       'PTR',           'IF',            'SPACE',                                                                                                                                                                                                                                                                                                                                                                                        
                 :   'FOR',           'SEMICOLON',     'INCDEC',        'TO',                                                                                                                                                                                                                                                                                                                                                                                           
                 :   'STEP',          'AS',            'APTR',          'LDELSLASH',                                                                                                                                                                                                                                                                                                                                                                                    
                 :   'INTEGER',       'COMMA',         'COLON',         'UNIMATH',                                                                                                                                                                                                                                                                                                                                                                                      
                 :   'OPENP',         'CLOSEP',        'QMARK',         'MATH',                                                                                                                                                                                                                                                                                                                                                                                         
                 :   'ANDSYM',        'TYPECAST',      'DOT',           'BOOLEAN',                                                                                                                                                                                                                                                                                                                                                                                      
                 :   'NULL',          'SINGLEQUOTESTRING',  'QUOTE',         'DOUBLECOLON',                                                                                                                                                                                                                                                                                                                                                                             
                 :   'AT',            'HATCH',         'OPENB',         'CLOSEB',                                                                                                                                                                                                                                                                                                                                                                                       
                 :   'VERT',          'NOT',           'ISIN',          'ISDIVBY',                                                                                                                                                                                                                                                                                                                                                                                      
                 :   'ISNOTDIVBY',    'ISEVEN',        'ISNOTEVEN',     'ISEVENBY',                                                                                                                                                                                                                                                                                                                                                                                     
                 :   'ISNOTEVENBY',   'ISODD',         'ISNOTODD',      'ISODDBY',                                                                                                                                                                                                                                                                                                                                                                                      
                 :   'ISNOTODDBY',    'INSTANCEOF',    'EQUALS',        'NOTEQUALS',                                                                                                                                                                                                                                                                                                                                                                                    
                 :   'GREATERTHAN',   'LESSTHAN',      'GREATEREQUAL',  'LESSEQUAL',                                                                                                                                                                                                                                                                                                                                                                                    
                 :   'IDENTITY',      'NONEIDENTITY',  'MOD',           'LAND',                                                                                                                                                                                                                                                                                                                                                                                         
                 :   'LOR',           'LXOR',          'BACKTICK',      'DOLLARID',                                                                                                                                                                                                                                                                                                                                                                                     
                 :   'error',         'start',         'template',      'template_element',                                                                                                                                                                                                                                                                                                                                                                             
                 :   'smartytag',     'value',         'attributes',    'variable',                                                                                                                                                                                                                                                                                                                                                                                     
                 :   'expr',          'ternary',       'varindexed',    'modifier',                                                                                                                                                                                                                                                                                                                                                                                     
                 :   'modparameters',  'ifexprs',       'statement',     'statements',                                                                                                                                                                                                                                                                                                                                                                                  
                 :   'optspace',      'varvar',        'foraction',     'array',                                                                                                                                                                                                                                                                                                                                                                                        
                 :   'specialclose',  'attribute',     'exprs',         'math',                                                                                                                                                                                                                                                                                                                                                                                         
                 :   'function',      'doublequoted',  'method',        'params',                                                                                                                                                                                                                                                                                                                                                                                       
                 :   'objectchain',   'arrayindex',    'object',        'indexdef',                                                                                                                                                                                                                                                                                                                                                                                     
                 :   'varvarele',     'objectelement',  'modparameter',  'ifexpr',                                                                                                                                                                                                                                                                                                                                                                                      
                 :   'ifcond',        'lop',           'arrayelements',  'arrayelement',                                                                                                                                                                                                                                                                                                                                                                                
                 :   'doublequotedcontent',                                                                                                                                                                                                                                                                                                                                                                                                                             
                 :     );                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * For tracing reduce actions, the names of all rules are required.                                                                                                                                                                                                                                                                                                                                                                              
                 :      * @var array                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static public $yyRuleName = array(                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*   0 */ "start ::= template",                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /*   1 */ "template ::= template_element",                                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /*   2 */ "template ::= template template_element",                                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /*   3 */ "template_element ::= smartytag",                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /*   4 */ "template_element ::= COMMENT",                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /*   5 */ "template_element ::= PHP OTHER SHORTTAGEND",                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*   6 */ "template_element ::= SHORTTAGSTART OTHER SHORTTAGEND",                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /*   7 */ "template_element ::= XML",                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*   8 */ "template_element ::= SHORTTAGEND",                                                                                                                                                                                                                                                                                                                                                                                                       
                 :  /*   9 */ "template_element ::= OTHER",                                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*  10 */ "smartytag ::= LDEL value RDEL",                                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /*  11 */ "smartytag ::= LDEL value attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*  12 */ "smartytag ::= LDEL variable attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  13 */ "smartytag ::= LDEL expr attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                                
                 :  /*  14 */ "smartytag ::= LDEL ternary attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*  15 */ "smartytag ::= LDEL DOLLAR ID EQUAL value RDEL",                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /*  16 */ "smartytag ::= LDEL DOLLAR ID EQUAL expr RDEL",                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /*  17 */ "smartytag ::= LDEL DOLLAR ID EQUAL expr attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                
                 :  /*  18 */ "smartytag ::= LDEL DOLLAR ID EQUAL ternary attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*  19 */ "smartytag ::= LDEL varindexed EQUAL expr attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*  20 */ "smartytag ::= LDEL varindexed EQUAL ternary attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  21 */ "smartytag ::= LDEL ID attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                                  
                 :  /*  22 */ "smartytag ::= LDEL FOREACH attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*  23 */ "smartytag ::= LDEL ID RDEL",                                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*  24 */ "smartytag ::= LDEL ID PTR ID attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /*  25 */ "smartytag ::= LDEL ID modifier modparameters attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                           
                 :  /*  26 */ "smartytag ::= LDEL ID PTR ID modifier modparameters attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                    
                 :  /*  27 */ "smartytag ::= LDEL IF SPACE ifexprs RDEL",                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*  28 */ "smartytag ::= LDEL IF SPACE statement RDEL",                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*  29 */ "smartytag ::= LDEL FOR SPACE statements SEMICOLON optspace ifexprs SEMICOLON optspace DOLLAR varvar foraction RDEL",                                                                                                                                                                                                                                                                                                                     
                 :  /*  30 */ "foraction ::= EQUAL expr",                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*  31 */ "foraction ::= INCDEC",                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /*  32 */ "smartytag ::= LDEL FOR SPACE statement TO expr RDEL",                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /*  33 */ "smartytag ::= LDEL FOR SPACE statement TO expr STEP expr RDEL",                                                                                                                                                                                                                                                                                                                                                                          
                 :  /*  34 */ "smartytag ::= LDEL FOREACH SPACE value AS DOLLAR varvar RDEL",                                                                                                                                                                                                                                                                                                                                                                           
                 :  /*  35 */ "smartytag ::= LDEL FOREACH SPACE value AS DOLLAR varvar APTR DOLLAR varvar RDEL",                                                                                                                                                                                                                                                                                                                                                        
                 :  /*  36 */ "smartytag ::= LDEL FOREACH SPACE array AS DOLLAR varvar RDEL",                                                                                                                                                                                                                                                                                                                                                                           
                 :  /*  37 */ "smartytag ::= LDEL FOREACH SPACE array AS DOLLAR varvar APTR DOLLAR varvar RDEL",                                                                                                                                                                                                                                                                                                                                                        
                 :  /*  38 */ "smartytag ::= LDELSLASH ID RDEL",                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /*  39 */ "smartytag ::= LDELSLASH specialclose RDEL",                                                                                                                                                                                                                                                                                                                                                                                              
                 :  /*  40 */ "specialclose ::= IF",                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /*  41 */ "specialclose ::= FOR",                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /*  42 */ "specialclose ::= FOREACH",                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*  43 */ "smartytag ::= LDELSLASH ID attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*  44 */ "smartytag ::= LDELSLASH ID modifier modparameters attributes RDEL",                                                                                                                                                                                                                                                                                                                                                                      
                 :  /*  45 */ "smartytag ::= LDELSLASH ID PTR ID RDEL",                                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /*  46 */ "attributes ::= attributes attribute",                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /*  47 */ "attributes ::= attribute",                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*  48 */ "attributes ::=",                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /*  49 */ "attribute ::= SPACE ID EQUAL ID",                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /*  50 */ "attribute ::= SPACE ID EQUAL expr",                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /*  51 */ "attribute ::= SPACE ID EQUAL value",                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /*  52 */ "attribute ::= SPACE ID EQUAL ternary",                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /*  53 */ "attribute ::= SPACE ID",                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /*  54 */ "attribute ::= SPACE INTEGER EQUAL expr",                                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /*  55 */ "statements ::= statement",                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /*  56 */ "statements ::= statements COMMA statement",                                                                                                                                                                                                                                                                                                                                                                                              
                 :  /*  57 */ "statement ::= DOLLAR varvar EQUAL expr",                                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /*  58 */ "expr ::= ID",                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  59 */ "expr ::= exprs",                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /*  60 */ "expr ::= DOLLAR ID COLON ID",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  61 */ "expr ::= expr modifier modparameters",                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /*  62 */ "exprs ::= value",                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /*  63 */ "exprs ::= UNIMATH value",                                                                                                                                                                                                                                                                                                                                                                                                                
                 :  /*  64 */ "exprs ::= exprs math value",                                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /*  65 */ "exprs ::= array",                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /*  66 */ "ternary ::= OPENP ifexprs CLOSEP QMARK expr COLON expr",                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /*  67 */ "ternary ::= OPENP expr CLOSEP QMARK expr COLON expr",                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /*  68 */ "math ::= UNIMATH",                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :  /*  69 */ "math ::= MATH",                                                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /*  70 */ "math ::= ANDSYM",                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /*  71 */ "value ::= variable",                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /*  72 */ "value ::= TYPECAST variable",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  73 */ "value ::= variable INCDEC",                                                                                                                                                                                                                                                                                                                                                                                                              
                 :  /*  74 */ "value ::= INTEGER",                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /*  75 */ "value ::= INTEGER DOT INTEGER",                                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /*  76 */ "value ::= BOOLEAN",                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /*  77 */ "value ::= NULL",                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /*  78 */ "value ::= function",                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /*  79 */ "value ::= OPENP expr CLOSEP",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  80 */ "value ::= SINGLEQUOTESTRING",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  81 */ "value ::= QUOTE doublequoted QUOTE",                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /*  82 */ "value ::= QUOTE QUOTE",                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :  /*  83 */ "value ::= ID DOUBLECOLON method",                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /*  84 */ "value ::= ID DOUBLECOLON DOLLAR ID OPENP params CLOSEP",                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /*  85 */ "value ::= ID DOUBLECOLON method objectchain",                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  86 */ "value ::= ID DOUBLECOLON DOLLAR ID OPENP params CLOSEP objectchain",                                                                                                                                                                                                                                                                                                                                                                     
                 :  /*  87 */ "value ::= ID DOUBLECOLON ID",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  88 */ "value ::= ID DOUBLECOLON DOLLAR ID arrayindex",                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /*  89 */ "value ::= ID DOUBLECOLON DOLLAR ID arrayindex objectchain",                                                                                                                                                                                                                                                                                                                                                                              
                 :  /*  90 */ "value ::= smartytag",                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /*  91 */ "variable ::= varindexed",                                                                                                                                                                                                                                                                                                                                                                                                                
                 :  /*  92 */ "variable ::= DOLLAR varvar AT ID",                                                                                                                                                                                                                                                                                                                                                                                                       
                 :  /*  93 */ "variable ::= object",                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /*  94 */ "variable ::= HATCH ID HATCH",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /*  95 */ "variable ::= HATCH variable HATCH",                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /*  96 */ "varindexed ::= DOLLAR varvar arrayindex",                                                                                                                                                                                                                                                                                                                                                                                                
                 :  /*  97 */ "arrayindex ::= arrayindex indexdef",                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /*  98 */ "arrayindex ::=",                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /*  99 */ "indexdef ::= DOT DOLLAR varvar",                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /* 100 */ "indexdef ::= DOT DOLLAR varvar AT ID",                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /* 101 */ "indexdef ::= DOT ID",                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /* 102 */ "indexdef ::= DOT BOOLEAN",                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /* 103 */ "indexdef ::= DOT NULL",                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :  /* 104 */ "indexdef ::= DOT INTEGER",                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /* 105 */ "indexdef ::= DOT LDEL exprs RDEL",                                                                                                                                                                                                                                                                                                                                                                                                       
                 :  /* 106 */ "indexdef ::= OPENB ID CLOSEB",                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 107 */ "indexdef ::= OPENB ID DOT ID CLOSEB",                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /* 108 */ "indexdef ::= OPENB exprs CLOSEB",                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /* 109 */ "indexdef ::= OPENB CLOSEB",                                                                                                                                                                                                                                                                                                                                                                                                              
                 :  /* 110 */ "varvar ::= varvarele",                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /* 111 */ "varvar ::= varvar varvarele",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /* 112 */ "varvarele ::= ID",                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :  /* 113 */ "varvarele ::= LDEL expr RDEL",                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 114 */ "object ::= varindexed objectchain",                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /* 115 */ "objectchain ::= objectelement",                                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /* 116 */ "objectchain ::= objectchain objectelement",                                                                                                                                                                                                                                                                                                                                                                                              
                 :  /* 117 */ "objectelement ::= PTR ID arrayindex",                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /* 118 */ "objectelement ::= PTR variable arrayindex",                                                                                                                                                                                                                                                                                                                                                                                              
                 :  /* 119 */ "objectelement ::= PTR LDEL expr RDEL arrayindex",                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /* 120 */ "objectelement ::= PTR ID LDEL expr RDEL arrayindex",                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /* 121 */ "objectelement ::= PTR method",                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 122 */ "function ::= ID OPENP params CLOSEP",                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /* 123 */ "method ::= ID OPENP params CLOSEP",                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /* 124 */ "params ::= expr COMMA params",                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 125 */ "params ::= expr",                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /* 126 */ "params ::=",                                                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /* 127 */ "modifier ::= VERT AT ID",                                                                                                                                                                                                                                                                                                                                                                                                                
                 :  /* 128 */ "modifier ::= VERT ID",                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /* 129 */ "modparameters ::= modparameters modparameter",                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 130 */ "modparameters ::=",                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /* 131 */ "modparameter ::= COLON exprs",                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 132 */ "modparameter ::= COLON ID",                                                                                                                                                                                                                                                                                                                                                                                                              
                 :  /* 133 */ "ifexprs ::= ifexpr",                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /* 134 */ "ifexprs ::= NOT ifexprs",                                                                                                                                                                                                                                                                                                                                                                                                                
                 :  /* 135 */ "ifexprs ::= OPENP ifexprs CLOSEP",                                                                                                                                                                                                                                                                                                                                                                                                       
                 :  /* 136 */ "ifexpr ::= expr",                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :  /* 137 */ "ifexpr ::= expr ifcond expr",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /* 138 */ "ifexpr ::= expr ISIN array",                                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /* 139 */ "ifexpr ::= expr ISIN value",                                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /* 140 */ "ifexpr ::= ifexprs lop ifexprs",                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /* 141 */ "ifexpr ::= ifexprs ISDIVBY ifexprs",                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /* 142 */ "ifexpr ::= ifexprs ISNOTDIVBY ifexprs",                                                                                                                                                                                                                                                                                                                                                                                                  
                 :  /* 143 */ "ifexpr ::= ifexprs ISEVEN",                                                                                                                                                                                                                                                                                                                                                                                                              
                 :  /* 144 */ "ifexpr ::= ifexprs ISNOTEVEN",                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 145 */ "ifexpr ::= ifexprs ISEVENBY ifexprs",                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /* 146 */ "ifexpr ::= ifexprs ISNOTEVENBY ifexprs",                                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /* 147 */ "ifexpr ::= ifexprs ISODD",                                                                                                                                                                                                                                                                                                                                                                                                               
                 :  /* 148 */ "ifexpr ::= ifexprs ISNOTODD",                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /* 149 */ "ifexpr ::= ifexprs ISODDBY ifexprs",                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /* 150 */ "ifexpr ::= ifexprs ISNOTODDBY ifexprs",                                                                                                                                                                                                                                                                                                                                                                                                  
                 :  /* 151 */ "ifexpr ::= value INSTANCEOF ID",                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /* 152 */ "ifexpr ::= value INSTANCEOF value",                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /* 153 */ "ifcond ::= EQUALS",                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /* 154 */ "ifcond ::= NOTEQUALS",                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /* 155 */ "ifcond ::= GREATERTHAN",                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /* 156 */ "ifcond ::= LESSTHAN",                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /* 157 */ "ifcond ::= GREATEREQUAL",                                                                                                                                                                                                                                                                                                                                                                                                                
                 :  /* 158 */ "ifcond ::= LESSEQUAL",                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /* 159 */ "ifcond ::= IDENTITY",                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :  /* 160 */ "ifcond ::= NONEIDENTITY",                                                                                                                                                                                                                                                                                                                                                                                                                
                 :  /* 161 */ "ifcond ::= MOD",                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /* 162 */ "lop ::= LAND",                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 163 */ "lop ::= LOR",                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :  /* 164 */ "lop ::= LXOR",                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :  /* 165 */ "array ::= OPENB arrayelements CLOSEB",                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /* 166 */ "arrayelements ::= arrayelement",                                                                                                                                                                                                                                                                                                                                                                                                         
                 :  /* 167 */ "arrayelements ::= arrayelements COMMA arrayelement",                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /* 168 */ "arrayelements ::=",                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /* 169 */ "arrayelement ::= value APTR expr",                                                                                                                                                                                                                                                                                                                                                                                                       
                 :  /* 170 */ "arrayelement ::= ID APTR expr",                                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /* 171 */ "arrayelement ::= expr",                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :  /* 172 */ "doublequoted ::= doublequoted doublequotedcontent",                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /* 173 */ "doublequoted ::= doublequotedcontent",                                                                                                                                                                                                                                                                                                                                                                                                   
                 :  /* 174 */ "doublequotedcontent ::= BACKTICK variable BACKTICK",                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /* 175 */ "doublequotedcontent ::= DOLLARID",                                                                                                                                                                                                                                                                                                                                                                                                       
                 :  /* 176 */ "doublequotedcontent ::= LDEL variable RDEL",                                                                                                                                                                                                                                                                                                                                                                                             
                 :  /* 177 */ "doublequotedcontent ::= LDEL expr RDEL",                                                                                                                                                                                                                                                                                                                                                                                                 
                 :  /* 178 */ "doublequotedcontent ::= smartytag",                                                                                                                                                                                                                                                                                                                                                                                                      
                 :  /* 179 */ "doublequotedcontent ::= OTHER",                                                                                                                                                                                                                                                                                                                                                                                                          
                 :  /* 180 */ "optspace ::= SPACE",                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :  /* 181 */ "optspace ::=",                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :     );                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * This function returns the symbolic name associated with a token                                                                                                                                                                                                                                                                                                                                                                               
                 :      * value.                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      * @param int                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      * @return string                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function tokenName($tokenType)                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         if ($tokenType === 0) {                                                                                                                                                                                                                                                                                                                                                                                                                      
               0 :             return 'End of Input';                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :         if ($tokenType > 0 && $tokenType < count($this->yyTokenName)) {                                                                                                                                                                                                                                                                                                                                                                              
               0 :             return $this->yyTokenName[$tokenType];                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         } else {                                                                                                                                                                                                                                                                                                                                                                                                                                     
               0 :             return "Unknown";                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * The following function deletes the value associated with a                                                                                                                                                                                                                                                                                                                                                                                    
                 :      * symbol.  The symbol can be either a terminal or nonterminal.                                                                                                                                                                                                                                                                                                                                                                                  
                 :      * @param int the symbol code                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      * @param mixed the symbol's value                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static function yy_destructor($yymajor, $yypminor)                                                                                                                                                                                                                                                                                                                                                                                               
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :         switch ($yymajor) {                                                                                                                                                                                                                                                                                                                                                                                                                          
                 :         /* Here is inserted the actions which take place when a                                                                                                                                                                                                                                                                                                                                                                                      
                 :         ** terminal or non-terminal is destroyed.  This can happen                                                                                                                                                                                                                                                                                                                                                                                   
                 :         ** when the symbol is popped from the stack during a                                                                                                                                                                                                                                                                                                                                                                                         
                 :         ** reduce or during error processing or when a parser is                                                                                                                                                                                                                                                                                                                                                                                     
                 :         ** being destroyed before it is finished parsing.                                                                                                                                                                                                                                                                                                                                                                                            
                 :         **                                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :         ** Note: during a reduce, the only symbols destroyed are those                                                                                                                                                                                                                                                                                                                                                                               
                 :         ** which appear on the RHS of the rule, but which are not used                                                                                                                                                                                                                                                                                                                                                                               
                 :         ** inside the C code.                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         */                                                                                                                                                                                                                                                                                                                                                                                                                                           
             391 :             default:  break;   /* If no destructor action specified: do nothing */                                                                                                                                                                                                                                                                                                                                                                   
             391 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             391 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Pop the parser's stack once.                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * If there is a destructor routine associated with the token which                                                                                                                                                                                                                                                                                                                                                                              
                 :      * is popped from the stack, then call it.                                                                                                                                                                                                                                                                                                                                                                                                       
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * Return the major token number for the symbol popped.                                                                                                                                                                                                                                                                                                                                                                                          
                 :      * @param TP_yyParser                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :      * @return int                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_pop_parser_stack()                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
             391 :         if (!count($this->yystack)) {                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :             return;                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             391 :         $yytos = array_pop($this->yystack);                                                                                                                                                                                                                                                                                                                                                                                                          
             391 :         if (self::$yyTraceFILE && $this->yyidx >= 0) {                                                                                                                                                                                                                                                                                                                                                                                               
               0 :             fwrite(self::$yyTraceFILE,                                                                                                                                                                                                                                                                                                                                                                                                               
               0 :                 self::$yyTracePrompt . 'Popping ' . $this->yyTokenName[$yytos->major] .                                                                                                                                                                                                                                                                                                                                                              
               0 :                     "\n");                                                                                                                                                                                                                                                                                                                                                                                                                           
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             391 :         $yymajor = $yytos->major;                                                                                                                                                                                                                                                                                                                                                                                                                    
             391 :         self::yy_destructor($yymajor, $yytos->minor);                                                                                                                                                                                                                                                                                                                                                                                                
             391 :         $this->yyidx--;                                                                                                                                                                                                                                                                                                                                                                                                                              
             391 :         return $yymajor;                                                                                                                                                                                                                                                                                                                                                                                                                             
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Deallocate and destroy a parser.  Destructors are all called for                                                                                                                                                                                                                                                                                                                                                                              
                 :      * all stack elements before shutting the parser down.                                                                                                                                                                                                                                                                                                                                                                                           
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function __destruct()                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               2 :         while ($this->yyidx >= 0) {                                                                                                                                                                                                                                                                                                                                                                                                                  
               2 :             $this->yy_pop_parser_stack();                                                                                                                                                                                                                                                                                                                                                                                                            
               2 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               2 :         if (is_resource(self::$yyTraceFILE)) {                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :             fclose(self::$yyTraceFILE);                                                                                                                                                                                                                                                                                                                                                                                                              
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               2 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Based on the current state and parser stack, get a list of all                                                                                                                                                                                                                                                                                                                                                                                
                 :      * possible lookahead tokens                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :      * @param int                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      * @return array                                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_get_expected_tokens($token)                                                                                                                                                                                                                                                                                                                                                                                                          
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               1 :         $state = $this->yystack[$this->yyidx]->stateno;                                                                                                                                                                                                                                                                                                                                                                                              
               1 :         $expected = self::$yyExpectedTokens[$state];                                                                                                                                                                                                                                                                                                                                                                                                 
               1 :         if (in_array($token, self::$yyExpectedTokens[$state], true)) {                                                                                                                                                                                                                                                                                                                                                                               
               0 :             return $expected;                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               1 :         $stack = $this->yystack;                                                                                                                                                                                                                                                                                                                                                                                                                     
               1 :         $yyidx = $this->yyidx;                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         do {                                                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :             $yyact = $this->yy_find_shift_action($token);                                                                                                                                                                                                                                                                                                                                                                                            
               1 :             if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {                                                                                                                                                                                                                                                                                                                                                               
                 :                 // reduce action                                                                                                                                                                                                                                                                                                                                                                                                                     
               0 :                 $done = 0;                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :                 do {                                                                                                                                                                                                                                                                                                                                                                                                                                 
               0 :                     if ($done++ == 100) {                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                         $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                     
                 :                         // too much recursion prevents proper detection                                                                                                                                                                                                                                                                                                                                                                              
                 :                         // so give up                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                         return array_unique($expected);                                                                                                                                                                                                                                                                                                                                                                                              
                 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                     $yyruleno = $yyact - self::YYNSTATE;                                                                                                                                                                                                                                                                                                                                                                                             
               0 :                     $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];                                                                                                                                                                                                                                                                                                                                                                             
               0 :                     $nextstate = $this->yy_find_reduce_action(                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         $this->yystack[$this->yyidx]->stateno,                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         self::$yyRuleInfo[$yyruleno]['lhs']);                                                                                                                                                                                                                                                                                                                                                                                        
               0 :                     if (isset(self::$yyExpectedTokens[$nextstate])) {                                                                                                                                                                                                                                                                                                                                                                                
               0 :                         $expected += self::$yyExpectedTokens[$nextstate];                                                                                                                                                                                                                                                                                                                                                                            
               0 :                             if (in_array($token,                                                                                                                                                                                                                                                                                                                                                                                                     
               0 :                                   self::$yyExpectedTokens[$nextstate], true)) {                                                                                                                                                                                                                                                                                                                                                                      
               0 :                             $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                   
               0 :                             $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                 
               0 :                             return array_unique($expected);                                                                                                                                                                                                                                                                                                                                                                                          
                 :                         }                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                     if ($nextstate < self::YYNSTATE) {                                                                                                                                                                                                                                                                                                                                                                                               
                 :                         // we need to shift a non-terminal                                                                                                                                                                                                                                                                                                                                                                                           
               0 :                         $this->yyidx++;                                                                                                                                                                                                                                                                                                                                                                                                              
               0 :                         $x = new TP_yyStackEntry;                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :                         $x->stateno = $nextstate;                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :                         $x->major = self::$yyRuleInfo[$yyruleno]['lhs'];                                                                                                                                                                                                                                                                                                                                                                             
               0 :                         $this->yystack[$this->yyidx] = $x;                                                                                                                                                                                                                                                                                                                                                                                           
               0 :                         continue 2;                                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :                     } elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {                                                                                                                                                                                                                                                                                                                                                                    
               0 :                         $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                     
                 :                         // the last token was just ignored, we can't accept                                                                                                                                                                                                                                                                                                                                                                          
                 :                         // by ignoring input, this is in essence ignoring a                                                                                                                                                                                                                                                                                                                                                                          
                 :                         // syntax error!                                                                                                                                                                                                                                                                                                                                                                                                             
               0 :                         return array_unique($expected);                                                                                                                                                                                                                                                                                                                                                                                              
               0 :                     } elseif ($nextstate === self::YY_NO_ACTION) {                                                                                                                                                                                                                                                                                                                                                                                   
               0 :                         $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                     
                 :                         // input accepted, but not shifted (I guess)                                                                                                                                                                                                                                                                                                                                                                                 
               0 :                         return $expected;                                                                                                                                                                                                                                                                                                                                                                                                            
                 :                     } else {                                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :                         $yyact = $nextstate;                                                                                                                                                                                                                                                                                                                                                                                                         
                 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                 } while (true);                                                                                                                                                                                                                                                                                                                                                                                                                      
               0 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
               1 :             break;                                                                                                                                                                                                                                                                                                                                                                                                                                   
               0 :         } while (true);                                                                                                                                                                                                                                                                                                                                                                                                                              
               1 :         return array_unique($expected);                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Based on the parser state and current parser stack, determine whether                                                                                                                                                                                                                                                                                                                                                                         
                 :      * the lookahead token is possible.                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * The parser will convert the token value to an error token if not.  This                                                                                                                                                                                                                                                                                                                                                                       
                 :      * catches some unusual edge cases where the parser would fail.                                                                                                                                                                                                                                                                                                                                                                                  
                 :      * @param int                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      * @return bool                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_is_expected_token($token)                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
             403 :         if ($token === 0) {                                                                                                                                                                                                                                                                                                                                                                                                                          
             397 :             return true; // 0 is not part of this                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :         $state = $this->yystack[$this->yyidx]->stateno;                                                                                                                                                                                                                                                                                                                                                                                              
             403 :         if (in_array($token, self::$yyExpectedTokens[$state], true)) {                                                                                                                                                                                                                                                                                                                                                                               
             403 :             return true;                                                                                                                                                                                                                                                                                                                                                                                                                             
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             379 :         $stack = $this->yystack;                                                                                                                                                                                                                                                                                                                                                                                                                     
             379 :         $yyidx = $this->yyidx;                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :         do {                                                                                                                                                                                                                                                                                                                                                                                                                                         
             379 :             $yyact = $this->yy_find_shift_action($token);                                                                                                                                                                                                                                                                                                                                                                                            
             379 :             if ($yyact >= self::YYNSTATE && $yyact < self::YYNSTATE + self::YYNRULE) {                                                                                                                                                                                                                                                                                                                                                               
                 :                 // reduce action                                                                                                                                                                                                                                                                                                                                                                                                                     
             378 :                 $done = 0;                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :                 do {                                                                                                                                                                                                                                                                                                                                                                                                                                 
             378 :                     if ($done++ == 100) {                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                         $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                     
                 :                         // too much recursion prevents proper detection                                                                                                                                                                                                                                                                                                                                                                              
                 :                         // so give up                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                         return true;                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
             378 :                     $yyruleno = $yyact - self::YYNSTATE;                                                                                                                                                                                                                                                                                                                                                                                             
             378 :                     $this->yyidx -= self::$yyRuleInfo[$yyruleno]['rhs'];                                                                                                                                                                                                                                                                                                                                                                             
             378 :                     $nextstate = $this->yy_find_reduce_action(                                                                                                                                                                                                                                                                                                                                                                                       
             378 :                         $this->yystack[$this->yyidx]->stateno,                                                                                                                                                                                                                                                                                                                                                                                       
             378 :                         self::$yyRuleInfo[$yyruleno]['lhs']);                                                                                                                                                                                                                                                                                                                                                                                        
             378 :                     if (isset(self::$yyExpectedTokens[$nextstate]) &&                                                                                                                                                                                                                                                                                                                                                                                
             378 :                           in_array($token, self::$yyExpectedTokens[$nextstate], true)) {                                                                                                                                                                                                                                                                                                                                                             
             378 :                         $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                       
             378 :                         $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                     
             378 :                         return true;                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
             365 :                     if ($nextstate < self::YYNSTATE) {                                                                                                                                                                                                                                                                                                                                                                                               
                 :                         // we need to shift a non-terminal                                                                                                                                                                                                                                                                                                                                                                                           
             365 :                         $this->yyidx++;                                                                                                                                                                                                                                                                                                                                                                                                              
             365 :                         $x = new TP_yyStackEntry;                                                                                                                                                                                                                                                                                                                                                                                                    
             365 :                         $x->stateno = $nextstate;                                                                                                                                                                                                                                                                                                                                                                                                    
             365 :                         $x->major = self::$yyRuleInfo[$yyruleno]['lhs'];                                                                                                                                                                                                                                                                                                                                                                             
             365 :                         $this->yystack[$this->yyidx] = $x;                                                                                                                                                                                                                                                                                                                                                                                           
             365 :                         continue 2;                                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :                     } elseif ($nextstate == self::YYNSTATE + self::YYNRULE + 1) {                                                                                                                                                                                                                                                                                                                                                                    
               0 :                         $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                     
               0 :                         if (!$token) {                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                             // end of input: this is valid                                                                                                                                                                                                                                                                                                                                                                                           
               0 :                             return true;                                                                                                                                                                                                                                                                                                                                                                                                             
                 :                         }                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :                         // the last token was just ignored, we can't accept                                                                                                                                                                                                                                                                                                                                                                          
                 :                         // by ignoring input, this is in essence ignoring a                                                                                                                                                                                                                                                                                                                                                                          
                 :                         // syntax error!                                                                                                                                                                                                                                                                                                                                                                                                             
               0 :                         return false;                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                     } elseif ($nextstate === self::YY_NO_ACTION) {                                                                                                                                                                                                                                                                                                                                                                                   
               0 :                         $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                     
                 :                         // input accepted, but not shifted (I guess)                                                                                                                                                                                                                                                                                                                                                                                 
               0 :                         return true;                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :                     } else {                                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :                         $yyact = $nextstate;                                                                                                                                                                                                                                                                                                                                                                                                         
                 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                 } while (true);                                                                                                                                                                                                                                                                                                                                                                                                                      
               0 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
               1 :             break;                                                                                                                                                                                                                                                                                                                                                                                                                                   
               0 :         } while (true);                                                                                                                                                                                                                                                                                                                                                                                                                              
               1 :         $this->yyidx = $yyidx;                                                                                                                                                                                                                                                                                                                                                                                                                       
               1 :         $this->yystack = $stack;                                                                                                                                                                                                                                                                                                                                                                                                                     
               1 :         return true;                                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Find the appropriate action for a parser given the terminal                                                                                                                                                                                                                                                                                                                                                                                   
                 :      * look-ahead token iLookAhead.                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * If the look-ahead token is YYNOCODE, then check to see if the action is                                                                                                                                                                                                                                                                                                                                                                       
                 :      * independent of the look-ahead.  If it is, return the action, otherwise                                                                                                                                                                                                                                                                                                                                                                        
                 :      * return YY_NO_ACTION.                                                                                                                                                                                                                                                                                                                                                                                                                          
                 :      * @param int The look-ahead token                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_find_shift_action($iLookAhead)                                                                                                                                                                                                                                                                                                                                                                                                       
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
             403 :         $stateno = $this->yystack[$this->yyidx]->stateno;                                                                                                                                                                                                                                                                                                                                                                                            
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* if ($this->yyidx < 0) return self::YY_NO_ACTION;  */                                                                                                                                                                                                                                                                                                                                                                                      
             403 :         if (!isset(self::$yy_shift_ofst[$stateno])) {                                                                                                                                                                                                                                                                                                                                                                                                
                 :             // no shift actions                                                                                                                                                                                                                                                                                                                                                                                                                      
             402 :             return self::$yy_default[$stateno];                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :         $i = self::$yy_shift_ofst[$stateno];                                                                                                                                                                                                                                                                                                                                                                                                         
             403 :         if ($i === self::YY_SHIFT_USE_DFLT) {                                                                                                                                                                                                                                                                                                                                                                                                        
              17 :             return self::$yy_default[$stateno];                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :         if ($iLookAhead == self::YYNOCODE) {                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :             return self::YY_NO_ACTION;                                                                                                                                                                                                                                                                                                                                                                                                               
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :         $i += $iLookAhead;                                                                                                                                                                                                                                                                                                                                                                                                                           
             403 :         if ($i < 0 || $i >= self::YY_SZ_ACTTAB ||                                                                                                                                                                                                                                                                                                                                                                                                    
             403 :               self::$yy_lookahead[$i] != $iLookAhead) {                                                                                                                                                                                                                                                                                                                                                                                              
             399 :             if (count(self::$yyFallback) && $iLookAhead < count(self::$yyFallback)                                                                                                                                                                                                                                                                                                                                                                   
             399 :                    && ($iFallback = self::$yyFallback[$iLookAhead]) != 0) {                                                                                                                                                                                                                                                                                                                                                                          
               0 :                 if (self::$yyTraceFILE) {                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                     fwrite(self::$yyTraceFILE, self::$yyTracePrompt . "FALLBACK " .                                                                                                                                                                                                                                                                                                                                                                  
               0 :                         $this->yyTokenName[$iLookAhead] . " => " .                                                                                                                                                                                                                                                                                                                                                                                   
               0 :                         $this->yyTokenName[$iFallback] . "\n");                                                                                                                                                                                                                                                                                                                                                                                      
               0 :                 }                                                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :                 return $this->yy_find_shift_action($iFallback);                                                                                                                                                                                                                                                                                                                                                                                      
                 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
             399 :             return self::$yy_default[$stateno];                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         } else {                                                                                                                                                                                                                                                                                                                                                                                                                                     
             403 :             return self::$yy_action[$i];                                                                                                                                                                                                                                                                                                                                                                                                             
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Find the appropriate action for a parser given the non-terminal                                                                                                                                                                                                                                                                                                                                                                               
                 :      * look-ahead token $iLookAhead.                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * If the look-ahead token is self::YYNOCODE, then check to see if the action is                                                                                                                                                                                                                                                                                                                                                                 
                 :      * independent of the look-ahead.  If it is, return the action, otherwise                                                                                                                                                                                                                                                                                                                                                                        
                 :      * return self::YY_NO_ACTION.                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      * @param int Current state number                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * @param int The look-ahead token                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_find_reduce_action($stateno, $iLookAhead)                                                                                                                                                                                                                                                                                                                                                                                            
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :         /* $stateno = $this->yystack[$this->yyidx]->stateno; */                                                                                                                                                                                                                                                                                                                                                                                      
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
             399 :         if (!isset(self::$yy_reduce_ofst[$stateno])) {                                                                                                                                                                                                                                                                                                                                                                                               
               0 :             return self::$yy_default[$stateno];                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             399 :         $i = self::$yy_reduce_ofst[$stateno];                                                                                                                                                                                                                                                                                                                                                                                                        
             399 :         if ($i == self::YY_REDUCE_USE_DFLT) {                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :             return self::$yy_default[$stateno];                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             399 :         if ($iLookAhead == self::YYNOCODE) {                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :             return self::YY_NO_ACTION;                                                                                                                                                                                                                                                                                                                                                                                                               
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             399 :         $i += $iLookAhead;                                                                                                                                                                                                                                                                                                                                                                                                                           
             399 :         if ($i < 0 || $i >= self::YY_SZ_ACTTAB ||                                                                                                                                                                                                                                                                                                                                                                                                    
             399 :               self::$yy_lookahead[$i] != $iLookAhead) {                                                                                                                                                                                                                                                                                                                                                                                              
               0 :             return self::$yy_default[$stateno];                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         } else {                                                                                                                                                                                                                                                                                                                                                                                                                                     
             399 :             return self::$yy_action[$i];                                                                                                                                                                                                                                                                                                                                                                                                             
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Perform a shift action.                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :      * @param int The new state to shift in                                                                                                                                                                                                                                                                                                                                                                                                          
                 :      * @param int The major token to shift in                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      * @param mixed the minor token to shift in                                                                                                                                                                                                                                                                                                                                                                                                      
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_shift($yyNewState, $yyMajor, $yypMinor)                                                                                                                                                                                                                                                                                                                                                                                              
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
             403 :         $this->yyidx++;                                                                                                                                                                                                                                                                                                                                                                                                                              
             403 :         if ($this->yyidx >= self::YYSTACKDEPTH) {                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :             $this->yyidx--;                                                                                                                                                                                                                                                                                                                                                                                                                          
               0 :             if (self::$yyTraceFILE) {                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                 fprintf(self::$yyTraceFILE, "%sStack Overflow!\n", self::$yyTracePrompt);                                                                                                                                                                                                                                                                                                                                                            
               0 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :             while ($this->yyidx >= 0) {                                                                                                                                                                                                                                                                                                                                                                                                              
               0 :                 $this->yy_pop_parser_stack();                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :             /* Here code is inserted which will execute if the parser                                                                                                                                                                                                                                                                                                                                                                                
                 :             ** stack ever overflows */                                                                                                                                                                                                                                                                                                                                                                                                               
               0 :             return;                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :         $yytos = new TP_yyStackEntry;                                                                                                                                                                                                                                                                                                                                                                                                                
             403 :         $yytos->stateno = $yyNewState;                                                                                                                                                                                                                                                                                                                                                                                                               
             403 :         $yytos->major = $yyMajor;                                                                                                                                                                                                                                                                                                                                                                                                                    
             403 :         $yytos->minor = $yypMinor;                                                                                                                                                                                                                                                                                                                                                                                                                   
             403 :         array_push($this->yystack, $yytos);                                                                                                                                                                                                                                                                                                                                                                                                          
             403 :         if (self::$yyTraceFILE && $this->yyidx > 0) {                                                                                                                                                                                                                                                                                                                                                                                                
               0 :             fprintf(self::$yyTraceFILE, "%sShift %d\n", self::$yyTracePrompt,                                                                                                                                                                                                                                                                                                                                                                        
               0 :                 $yyNewState);                                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :             fprintf(self::$yyTraceFILE, "%sStack:", self::$yyTracePrompt);                                                                                                                                                                                                                                                                                                                                                                           
               0 :             for($i = 1; $i <= $this->yyidx; $i++) {                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :                 fprintf(self::$yyTraceFILE, " %s",                                                                                                                                                                                                                                                                                                                                                                                                   
               0 :                     $this->yyTokenName[$this->yystack[$i]->major]);                                                                                                                                                                                                                                                                                                                                                                                  
               0 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
               0 :             fwrite(self::$yyTraceFILE,"\n");                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * The following table contains information about every rule that                                                                                                                                                                                                                                                                                                                                                                                
                 :      * is used during the reduce.                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * <pre>                                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :      * array(                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      *  array(                                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :      *   int $lhs;         Symbol on the left-hand side of the rule                                                                                                                                                                                                                                                                                                                                                                                  
                 :      *   int $nrhs;     Number of right-hand side symbols in the rule                                                                                                                                                                                                                                                                                                                                                                                
                 :      *  ),...                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      * );                                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :      * </pre>                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static public $yyRuleInfo = array(                                                                                                                                                                                                                                                                                                                                                                                                               
                 :   array( 'lhs' => 73, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 74, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 74, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 75, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 75, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 75, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 75, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 75, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 75, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 75, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 7 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 7 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 8 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 5 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 5 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 13 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 90, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 90, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 7 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 9 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 8 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 11 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 76, 'rhs' => 8 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 11 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 76, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 92, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 92, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 92, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 76, 'rhs' => 5 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 78, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 78, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 78, 'rhs' => 0 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 93, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 93, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 93, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 93, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 93, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 93, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 87, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 87, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 86, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 80, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 80, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 80, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 80, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 94, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 94, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 94, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 94, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 81, 'rhs' => 7 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 81, 'rhs' => 7 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 95, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 95, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 95, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 7 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 8 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 5 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 77, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 79, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 79, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 79, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 79, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 79, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 82, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 101, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 101, 'rhs' => 0 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 5 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 5 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 103, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 89, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 89, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 104, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 104, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 102, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 100, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 100, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 105, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 105, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 105, 'rhs' => 5 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 105, 'rhs' => 6 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 105, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 96, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 98, 'rhs' => 4 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 99, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 99, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 99, 'rhs' => 0 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 83, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 83, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 84, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 84, 'rhs' => 0 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 106, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 106, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 85, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 85, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 85, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 107, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 107, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 108, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 109, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 109, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 109, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 91, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 110, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 110, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 110, 'rhs' => 0 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 111, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 111, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 111, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 97, 'rhs' => 2 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 97, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 112, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 112, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 112, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 112, 'rhs' => 3 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 112, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 112, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :   array( 'lhs' => 88, 'rhs' => 1 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :   array( 'lhs' => 88, 'rhs' => 0 ),                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :     );                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * The following table contains a mapping of reduce action to method name                                                                                                                                                                                                                                                                                                                                                                        
                 :      * that handles the reduction.                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * If a rule is not set, it has no handler.                                                                                                                                                                                                                                                                                                                                                                                                      
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     static public $yyReduceMap = array(                                                                                                                                                                                                                                                                                                                                                                                                              
                 :         0 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         40 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         41 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         42 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         62 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         71 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         74 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         76 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         77 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         78 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         80 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         93 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         166 => 0,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         1 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         59 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         65 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         68 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         69 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :         110 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         133 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         173 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         179 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         180 => 1,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         2 => 2,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         129 => 2,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         3 => 3,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         4 => 4,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         5 => 5,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         6 => 6,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         7 => 7,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         8 => 8,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         9 => 9,                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         10 => 10,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         11 => 11,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         12 => 11,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         13 => 11,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         14 => 11,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         15 => 15,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         16 => 15,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         17 => 17,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         18 => 17,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         19 => 19,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         20 => 19,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         21 => 21,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         22 => 21,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         23 => 23,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         24 => 24,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         25 => 25,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         26 => 26,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         27 => 27,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         28 => 27,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         29 => 29,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         30 => 30,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         31 => 31,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         47 => 31,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         125 => 31,                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         171 => 31,                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         32 => 32,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         33 => 33,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         34 => 34,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         35 => 35,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         36 => 36,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         37 => 37,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         38 => 38,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         39 => 38,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         43 => 43,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         44 => 44,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         45 => 45,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         46 => 46,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         48 => 48,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         49 => 49,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         50 => 50,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         51 => 50,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         52 => 50,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         54 => 50,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         53 => 53,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         55 => 55,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         56 => 56,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         57 => 57,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         58 => 58,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         60 => 60,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         61 => 61,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         63 => 63,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         72 => 63,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         73 => 63,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         64 => 64,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         66 => 66,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         67 => 66,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         70 => 70,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         75 => 75,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         79 => 79,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         81 => 81,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         82 => 82,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         83 => 83,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         84 => 84,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         85 => 85,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         86 => 86,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         87 => 87,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         88 => 88,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         89 => 89,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         90 => 90,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         91 => 91,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         92 => 92,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         94 => 94,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         95 => 95,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         96 => 96,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         97 => 97,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         172 => 97,                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         98 => 98,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         130 => 98,                                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :         99 => 99,                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :         100 => 100,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         101 => 101,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         102 => 101,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         103 => 101,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         104 => 104,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         105 => 105,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         108 => 105,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         106 => 106,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         107 => 107,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         109 => 109,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         181 => 109,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         111 => 111,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         112 => 112,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         113 => 113,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         135 => 113,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         114 => 114,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         115 => 115,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         116 => 116,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         117 => 117,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         118 => 118,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         119 => 119,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         120 => 120,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         121 => 121,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         122 => 122,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         123 => 123,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         124 => 124,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         126 => 126,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         127 => 127,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         128 => 128,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         131 => 131,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         132 => 132,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         134 => 134,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         136 => 136,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         137 => 137,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         140 => 137,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         151 => 137,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         138 => 138,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         139 => 139,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         141 => 141,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         142 => 142,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         143 => 143,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         148 => 143,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         144 => 144,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         147 => 144,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         145 => 145,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         150 => 145,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         146 => 146,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         149 => 146,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         152 => 152,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         153 => 153,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         154 => 154,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         155 => 155,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         156 => 156,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         157 => 157,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         158 => 158,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         159 => 159,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         160 => 160,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         161 => 161,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         162 => 162,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         163 => 163,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         164 => 164,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         165 => 165,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         167 => 167,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         168 => 168,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         169 => 169,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         170 => 170,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         174 => 174,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         176 => 174,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         175 => 175,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         177 => 177,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :         178 => 178,                                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :     );                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :     /* Beginning here are the reduction cases.  A typical example                                                                                                                                                                                                                                                                                                                                                                                    
                 :     ** follows:                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     **  #line <lineno> <grammarfile>                                                                                                                                                                                                                                                                                                                                                                                                                 
                 :     **   function yy_r0($yymsp){ ... }           // User supplied code                                                                                                                                                                                                                                                                                                                                                                               
                 :     **  #line <lineno> <thisfile>                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     */                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 : #line 78 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
             397 :     function yy_r0(){ $this->_retvalue = $this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                                                                                                              
                 : #line 2086 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 84 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
             396 :     function yy_r1(){$this->_retvalue = $this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                                                                
                 : #line 2089 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 86 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
             318 :     function yy_r2(){ $this->_retvalue = $this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                      
                 : #line 2092 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 92 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
                 :     function yy_r3(){                                                                                                                                                                                                                                                                                                                                                                                                                                
             368 :                                           if ($this->compiler->has_code) {                                                                                                                                                                                                                                                                                                                                                                           
             368 :                                             $tmp =''; foreach ($this->compiler->prefix_code as $code) {$tmp.=$code;} $this->compiler->prefix_code=array();                                                                                                                                                                                                                                                                                           
             368 :                                             $this->_retvalue = $this->cacher->processNocacheCode($tmp.$this->yystack[$this->yyidx + 0]->minor, $this->compiler,true);                                                                                                                                                                                                                                                                                
             368 :                                          } else { $this->_retvalue = $this->yystack[$this->yyidx + 0]->minor;}  $this->compiler->has_variable_string = false;    }                                                                                                                                                                                                                                                                                   
                 : #line 2099 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 99 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
               8 :     function yy_r4(){ $this->_retvalue = '';    }                                                                                                                                                                                                                                                                                                                                                                                                    
                 : #line 2102 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 104 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               4 :     function yy_r5(){if ($this->sec_obj->php_handling == SMARTY_PHP_PASSTHRU) {                                                                                                                                                                                                                                                                                                                                                                      
               1 :                                        $this->_retvalue = $this->cacher->processNocacheCode("<?php echo htmlspecialchars('<?php".str_replace("'","\'",$this->yystack[$this->yyidx + -1]->minor)."?>', ENT_QUOTES);?>\n", $this->compiler, false);                                                                                                                                                                                                    
               4 :                                       } elseif ($this->sec_obj->php_handling == SMARTY_PHP_QUOTE) {                                                                                                                                                                                                                                                                                                                                                  
               1 :                                        $this->_retvalue = $this->cacher->processNocacheCode(htmlspecialchars('<?php'.$this->yystack[$this->yyidx + -1]->minor.'?>', ENT_QUOTES), $this->compiler, false);                                                                                                                                                                                                                                            
               3 :                                       }elseif ($this->sec_obj->php_handling == SMARTY_PHP_ALLOW) {                                                                                                                                                                                                                                                                                                                                                   
               2 :                                        $this->_retvalue = $this->cacher->processNocacheCode('<?php'.$this->yystack[$this->yyidx + -1]->minor.'?>', $this->compiler, true);                                                                                                                                                                                                                                                                           
               2 :                                       }elseif ($this->sec_obj->php_handling == SMARTY_PHP_REMOVE) {                                                                                                                                                                                                                                                                                                                                                  
               0 :                                        $this->_retvalue = '';                                                                                                                                                                                                                                                                                                                                                                                        
               0 :                                       }                                                                                                                                                                                                                                                                                                                                                                                                              
               4 :                                          }                                                                                                                                                                                                                                                                                                                                                                                                           
                 : #line 2114 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 115 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
                 :     function yy_r6(){                                                                                                                                                                                                                                                                                                                                                                                                                                
               1 :                                       if ($this->sec_obj->php_handling == SMARTY_PHP_PASSTHRU || $this->sec_obj->php_handling == SMARTY_PHP_ALLOW) {                                                                                                                                                                                                                                                                                                 
               1 :                                        $this->_retvalue = $this->cacher->processNocacheCode("<?php echo '<?=".$this->yystack[$this->yyidx + -1]->minor."?>'?>\n", $this->compiler, false);                                                                                                                                                                                                                                                           
               1 :                                       } elseif ($this->sec_obj->php_handling == SMARTY_PHP_QUOTE) {                                                                                                                                                                                                                                                                                                                                                  
               0 :                                        $this->_retvalue = $this->cacher->processNocacheCode(htmlspecialchars('<?='.$this->yystack[$this->yyidx + -1]->minor.'?>', ENT_QUOTES), $this->compiler, false);                                                                                                                                                                                                                                              
               0 :                                       }elseif ($this->sec_obj == SMARTY_PHP_REMOVE) {                                                                                                                                                                                                                                                                                                                                                                
               0 :                                        $this->_retvalue = '';                                                                                                                                                                                                                                                                                                                                                                                        
               0 :                                       }                                                                                                                                                                                                                                                                                                                                                                                                              
               1 :                                          }                                                                                                                                                                                                                                                                                                                                                                                                           
                 : #line 2125 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 126 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r7(){ $this->compiler->tag_nocache = true; $this->_retvalue = $this->cacher->processNocacheCode("<?php echo '<?xml';?>", $this->compiler, true);    }                                                                                                                                                                                                                                                                                
                 : #line 2128 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 127 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r8(){$this->compiler->tag_nocache = true; $this->_retvalue = $this->cacher->processNocacheCode("<?php echo '?>';?>\n", $this->compiler, true);    }                                                                                                                                                                                                                                                                                  
                 : #line 2131 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 129 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             212 :     function yy_r9(){$this->_retvalue = $this->cacher->processNocacheCode($this->yystack[$this->yyidx + 0]->minor, $this->compiler,false);    }                                                                                                                                                                                                                                                                                                      
                 : #line 2134 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 137 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              18 :     function yy_r10(){ $this->_retvalue = $this->compiler->compileTag('print_expression',array('value'=>$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                                                                                                                             
                 : #line 2137 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 138 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             226 :     function yy_r11(){ $this->_retvalue = $this->compiler->compileTag('print_expression',array_merge(array('value'=>$this->yystack[$this->yyidx + -2]->minor),$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                                                                       
                 : #line 2140 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 149 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              68 :     function yy_r15(){ $this->_retvalue = $this->compiler->compileTag('assign',array('value'=>$this->yystack[$this->yyidx + -1]->minor,'var'=>"'".$this->yystack[$this->yyidx + -3]->minor."'"));    }                                                                                                                                                                                                                                               
                 : #line 2143 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 151 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r17(){ $this->_retvalue = $this->compiler->compileTag('assign',array_merge(array('value'=>$this->yystack[$this->yyidx + -2]->minor,'var'=>"'".$this->yystack[$this->yyidx + -4]->minor."'"),$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                         
                 : #line 2146 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 153 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              11 :     function yy_r19(){ $this->_retvalue = $this->compiler->compileTag('assign',array_merge(array('value'=>$this->yystack[$this->yyidx + -2]->minor),$this->yystack[$this->yyidx + -4]->minor,$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                                        
                 : #line 2149 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 156 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             114 :     function yy_r21(){ $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -2]->minor,$this->yystack[$this->yyidx + -1]->minor);    }                                                                                                                                                                                                                                                                                       
                 : #line 2152 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 158 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             120 :     function yy_r23(){ $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -1]->minor,array());    }                                                                                                                                                                                                                                                                                                                        
                 : #line 2155 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 160 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r24(){ $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -4]->minor,array_merge(array('object_methode'=>$this->yystack[$this->yyidx + -2]->minor),$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                                        
                 : #line 2158 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 162 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r25(){  $this->_retvalue = '<?php ob_start();?>'.$this->compiler->compileTag($this->yystack[$this->yyidx + -4]->minor,$this->yystack[$this->yyidx + -1]->minor).'<?php echo ';                                                                                                                                                                                                                                                       
               1 :                                                                                                if ($this->smarty->plugin_handler->loadSmartyPlugin($this->yystack[$this->yyidx + -3]->minor[0],'modifier')) {                                                                                                                                                                                                                                        
               1 :                                                                       $this->_retvalue .= "\$_smarty_tpl->smarty->plugin_handler->executeModifier('".$this->yystack[$this->yyidx + -3]->minor[0] . "',array(ob_get_clean()" . $this->yystack[$this->yyidx + -2]->minor. "),".$this->yystack[$this->yyidx + -3]->minor[1].");?>";                                                                                                                     
               1 :                                                                  } else {                                                                                                                                                                                                                                                                                                                                                                            
               0 :                                                                    if (is_callable($this->yystack[$this->yyidx + -3]->minor[0])) {                                                                                                                                                                                                                                                                                                                   
               0 :                                                                                                                 if (!$this->template->security || $this->smarty->security_handler->isTrustedModifier($this->yystack[$this->yyidx + -3]->minor[0], $this->compiler)) {                                                                                                                                                                                
               0 :                                                                          $this->_retvalue .= "\$_smarty_tpl->smarty->plugin_handler->executeModifier('".$this->yystack[$this->yyidx + -3]->minor[0] . "',array(ob_get_clean()" . $this->yystack[$this->yyidx + -2]->minor. "),".$this->yystack[$this->yyidx + -3]->minor[1].");?>";                                                                                                                  
               0 :                                                                                                                 }                                                                                                                                                                                                                                                                                                                                    
               0 :                                                                                                              } else {                                                                                                                                                                                                                                                                                                                                
               0 :                                                                       $this->compiler->trigger_template_error ("unknown modifier \"" . $this->yystack[$this->yyidx + -3]->minor[0] . "\"");                                                                                                                                                                                                                                                          
                 :                                                                  }                                                                                                                                                                                                                                                                                                                                                                                   
                 :                                                               }                                                                                                                                                                                                                                                                                                                                                                                      
               1 :                                                                         }                                                                                                                                                                                                                                                                                                                                                                            
                 : #line 2173 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 176 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r26(){  $this->_retvalue = '<?php ob_start();?>'.$this->compiler->compileTag($this->yystack[$this->yyidx + -6]->minor,array_merge(array('object_methode'=>$this->yystack[$this->yyidx + -4]->minor),$this->yystack[$this->yyidx + -1]->minor)).'<?php echo ';                                                                                                                                                                        
               1 :                                                                                                if ($this->smarty->plugin_handler->loadSmartyPlugin($this->yystack[$this->yyidx + -3]->minor[0],'modifier')) {                                                                                                                                                                                                                                        
               1 :                                                                       $this->_retvalue .= "\$_smarty_tpl->smarty->plugin_handler->executeModifier('".$this->yystack[$this->yyidx + -3]->minor[0] . "',array(ob_get_clean()" . $this->yystack[$this->yyidx + -2]->minor. "),".$this->yystack[$this->yyidx + -3]->minor[1].");?>";                                                                                                                     
               1 :                                                                  } else {                                                                                                                                                                                                                                                                                                                                                                            
               0 :                                                                    if (is_callable($this->yystack[$this->yyidx + -3]->minor[0])) {                                                                                                                                                                                                                                                                                                                   
               0 :                                                                                                                 if (!$this->template->security || $this->smarty->security_handler->isTrustedModifier($this->yystack[$this->yyidx + -3]->minor[0], $this->compiler)) {                                                                                                                                                                                
               0 :                                                                          $this->_retvalue .= "\$_smarty_tpl->smarty->plugin_handler->executeModifier('".$this->yystack[$this->yyidx + -3]->minor[0] . "',array(ob_get_clean()" . $this->yystack[$this->yyidx + -2]->minor. "),".$this->yystack[$this->yyidx + -3]->minor[1].");?>";                                                                                                                  
               0 :                                                                                                                 }                                                                                                                                                                                                                                                                                                                                    
               0 :                                                                                                              } else {                                                                                                                                                                                                                                                                                                                                
               0 :                                                                       $this->compiler->trigger_template_error ("unknown modifier \"" . $this->yystack[$this->yyidx + -3]->minor[0] . "\"");                                                                                                                                                                                                                                                          
                 :                                                                  }                                                                                                                                                                                                                                                                                                                                                                                   
                 :                                                               }                                                                                                                                                                                                                                                                                                                                                                                      
               1 :                                                                         }                                                                                                                                                                                                                                                                                                                                                                            
                 : #line 2188 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 190 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              85 :     function yy_r27(){ $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -3]->minor,array('if condition'=>$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                                                                                                
                 : #line 2191 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 193 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
                 :     function yy_r29(){                                                                                                                                                                                                                                                                                                                                                                                                                               
               7 :                                                              $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -11]->minor,array('start'=>$this->yystack[$this->yyidx + -9]->minor,'ifexp'=>$this->yystack[$this->yyidx + -6]->minor,'varloop'=>$this->yystack[$this->yyidx + -2]->minor,'loop'=>$this->yystack[$this->yyidx + -1]->minor));    }                                                                         
                 : #line 2195 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 195 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r30(){ $this->_retvalue = '='.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                                                          
                 : #line 2198 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 196 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             147 :     function yy_r31(){ $this->_retvalue = $this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                                                              
                 : #line 2201 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 197 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r32(){ $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -5]->minor,array('start'=>$this->yystack[$this->yyidx + -3]->minor,'to'=>$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                                                        
                 : #line 2204 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 198 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               5 :     function yy_r33(){ $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -7]->minor,array('start'=>$this->yystack[$this->yyidx + -5]->minor,'to'=>$this->yystack[$this->yyidx + -3]->minor,'step'=>$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                       
                 : #line 2207 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 200 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
                 :     function yy_r34(){                                                                                                                                                                                                                                                                                                                                                                                                                               
              16 :                                                             $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -6]->minor,array('from'=>$this->yystack[$this->yyidx + -4]->minor,'item'=>$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                  
                 : #line 2211 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 202 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
                 :     function yy_r35(){                                                                                                                                                                                                                                                                                                                                                                                                                               
               0 :                                                             $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -9]->minor,array('from'=>$this->yystack[$this->yyidx + -7]->minor,'item'=>$this->yystack[$this->yyidx + -1]->minor,'key'=>$this->yystack[$this->yyidx + -4]->minor));    }                                                                                                                                  
                 : #line 2215 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 204 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
                 :     function yy_r36(){                                                                                                                                                                                                                                                                                                                                                                                                                               
               1 :                                                             $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -6]->minor,array('from'=>$this->yystack[$this->yyidx + -4]->minor,'item'=>$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                  
                 : #line 2219 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 206 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
                 :     function yy_r37(){                                                                                                                                                                                                                                                                                                                                                                                                                               
               0 :                                                             $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -9]->minor,array('from'=>$this->yystack[$this->yyidx + -7]->minor,'item'=>$this->yystack[$this->yyidx + -1]->minor,'key'=>$this->yystack[$this->yyidx + -4]->minor));    }                                                                                                                                  
                 : #line 2223 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 210 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             160 :     function yy_r38(){ $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -1]->minor.'close',array());    }                                                                                                                                                                                                                                                                                                                
                 : #line 2226 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 215 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r43(){ $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -2]->minor.'close',$this->yystack[$this->yyidx + -1]->minor);    }                                                                                                                                                                                                                                                                               
                 : #line 2229 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 216 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r44(){  $this->_retvalue = '<?php ob_start();?>'.$this->compiler->compileTag($this->yystack[$this->yyidx + -4]->minor.'close',$this->yystack[$this->yyidx + -1]->minor).'<?php echo ';                                                                                                                                                                                                                                               
               0 :                                                                                                if ($this->smarty->plugin_handler->loadSmartyPlugin($this->yystack[$this->yyidx + -3]->minor[0],'modifier')) {                                                                                                                                                                                                                                        
               0 :                                                                       $this->_retvalue .= "\$_smarty_tpl->smarty->plugin_handler->executeModifier('".$this->yystack[$this->yyidx + -3]->minor[0] . "',array(ob_get_clean()" . $this->yystack[$this->yyidx + -2]->minor. "),".$this->yystack[$this->yyidx + -3]->minor[1].");?>";                                                                                                                     
               0 :                                                                  } else {                                                                                                                                                                                                                                                                                                                                                                            
               0 :                                                                    if (is_callable($this->yystack[$this->yyidx + -3]->minor[0])) {                                                                                                                                                                                                                                                                                                                   
               0 :                                                                                                                 if (!$this->template->security || $this->smarty->security_handler->isTrustedModifier($this->yystack[$this->yyidx + -3]->minor[0], $this->compiler)) {                                                                                                                                                                                
               0 :                                                                          $this->_retvalue .= "\$_smarty_tpl->smarty->plugin_handler->executeModifier('".$this->yystack[$this->yyidx + -3]->minor[0] . "',array(ob_get_clean()" . $this->yystack[$this->yyidx + -2]->minor. "),".$this->yystack[$this->yyidx + -3]->minor[1].");?>";                                                                                                                  
               0 :                                                                                                                 }                                                                                                                                                                                                                                                                                                                                    
               0 :                                                                                                              } else {                                                                                                                                                                                                                                                                                                                                
               0 :                                                                       $this->compiler->trigger_template_error ("unknown modifier \"" . $this->yystack[$this->yyidx + -3]->minor[0] . "\"");                                                                                                                                                                                                                                                          
                 :                                                                  }                                                                                                                                                                                                                                                                                                                                                                                   
                 :                                                               }                                                                                                                                                                                                                                                                                                                                                                                      
               0 :                                                                         }                                                                                                                                                                                                                                                                                                                                                                            
                 : #line 2244 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 230 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r45(){  $this->_retvalue = $this->compiler->compileTag($this->yystack[$this->yyidx + -3]->minor.'close',array('object_methode'=>$this->yystack[$this->yyidx + -1]->minor));    }                                                                                                                                                                                                                                                     
                 : #line 2247 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 237 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              72 :     function yy_r46(){ $this->_retvalue = array_merge($this->yystack[$this->yyidx + -1]->minor,$this->yystack[$this->yyidx + 0]->minor);    }                                                                                                                                                                                                                                                                                                        
                 : #line 2250 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 241 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             229 :     function yy_r48(){ $this->_retvalue = array();    }                                                                                                                                                                                                                                                                                                                                                                                              
                 : #line 2253 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 244 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              79 :     function yy_r49(){ $this->_retvalue = array($this->yystack[$this->yyidx + -2]->minor=>"'".$this->yystack[$this->yyidx + 0]->minor."'");    }                                                                                                                                                                                                                                                                                                     
                 : #line 2256 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 245 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             104 :     function yy_r50(){ $this->_retvalue = array($this->yystack[$this->yyidx + -2]->minor=>$this->yystack[$this->yyidx + 0]->minor);    }                                                                                                                                                                                                                                                                                                             
                 : #line 2259 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 248 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r53(){ $this->_retvalue = array($this->yystack[$this->yyidx + 0]->minor=>'true');    }                                                                                                                                                                                                                                                                                                                                               
                 : #line 2262 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 255 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               7 :     function yy_r55(){ $this->_retvalue = array($this->yystack[$this->yyidx + 0]->minor);    }                                                                                                                                                                                                                                                                                                                                                       
                 : #line 2265 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 256 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r56(){ $this->yystack[$this->yyidx + -2]->minor[]=$this->yystack[$this->yyidx + 0]->minor; $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor;    }                                                                                                                                                                                                                                                                         
                 : #line 2268 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 258 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              16 :     function yy_r57(){ $this->_retvalue = array('var' => $this->yystack[$this->yyidx + -2]->minor, 'value'=>$this->yystack[$this->yyidx + 0]->minor);    }                                                                                                                                                                                                                                                                                           
                 : #line 2271 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 264 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r58(){ $this->_retvalue = '\''.$this->yystack[$this->yyidx + 0]->minor.'\'';     }                                                                                                                                                                                                                                                                                                                                                   
                 : #line 2274 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 267 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r60(){$this->_retvalue = '$_smarty_tpl->getStreamVariable(\''. $this->yystack[$this->yyidx + -2]->minor .'://'. $this->yystack[$this->yyidx + 0]->minor . '\')';    }                                                                                                                                                                                                                                                                
                 : #line 2277 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 268 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
                 :     function yy_r61(){                                                                                                                                                                                                                                                                                                                                                                                                                               
              15 :                                                             if ($this->smarty->plugin_handler->loadSmartyPlugin($this->yystack[$this->yyidx + -1]->minor[0],'modifier')) {                                                                                                                                                                                                                                                                           
               7 :                                                                       $this->_retvalue = "\$_smarty_tpl->smarty->plugin_handler->executeModifier('".$this->yystack[$this->yyidx + -1]->minor[0] . "',array(". $this->yystack[$this->yyidx + -2]->minor . $this->yystack[$this->yyidx + 0]->minor. "),".$this->yystack[$this->yyidx + -1]->minor[1].")";                                                                                              
               7 :                                                                  } else {                                                                                                                                                                                                                                                                                                                                                                            
               9 :                                                                    if (is_callable($this->yystack[$this->yyidx + -1]->minor[0])) {                                                                                                                                                                                                                                                                                                                   
               8 :                                                                                                                 if (!$this->template->security || $this->smarty->security_handler->isTrustedModifier($this->yystack[$this->yyidx + -1]->minor[0], $this->compiler)) {                                                                                                                                                                                
               7 :                                                                          $this->_retvalue = "\$_smarty_tpl->smarty->plugin_handler->executeModifier('".$this->yystack[$this->yyidx + -1]->minor[0] . "',array(". $this->yystack[$this->yyidx + -2]->minor . $this->yystack[$this->yyidx + 0]->minor. "),".$this->yystack[$this->yyidx + -1]->minor[1].")";                                                                                           
               7 :                                                                                                                 }                                                                                                                                                                                                                                                                                                                                    
               7 :                                                                                                              } else {                                                                                                                                                                                                                                                                                                                                
               1 :                                                                       $this->compiler->trigger_template_error ("unknown modifier \"" . $this->yystack[$this->yyidx + -1]->minor[0] . "\"");                                                                                                                                                                                                                                                          
                 :                                                                  }                                                                                                                                                                                                                                                                                                                                                                                   
                 :                                                               }                                                                                                                                                                                                                                                                                                                                                                                      
              13 :                                                                 }                                                                                                                                                                                                                                                                                                                                                                                    
                 : #line 2292 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 285 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r63(){ $this->_retvalue = $this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                                                                    
                 : #line 2295 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 287 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              20 :     function yy_r64(){ $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor . $this->yystack[$this->yyidx + -1]->minor . $this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                       
                 : #line 2298 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 294 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              17 :     function yy_r66(){ $this->_retvalue = $this->yystack[$this->yyidx + -5]->minor.' ? '.$this->yystack[$this->yyidx + -2]->minor.' : '.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                
                 : #line 2301 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 308 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r70(){$this->_retvalue = ' & ';    }                                                                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2304 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 316 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r75(){ $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor.'.'.$this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                                                                
                 : #line 2307 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 326 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r79(){ $this->_retvalue = "(". $this->yystack[$this->yyidx + -1]->minor .")";     }                                                                                                                                                                                                                                                                                                                                                  
                 : #line 2310 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 330 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              55 :     function yy_r81(){ $_s = str_replace(array('."".','.""'),array('.',''),'"'.$this->yystack[$this->yyidx + -1]->minor.'"');                                                                                                                                                                                                                                                                                                                        
              55 :                                                     if (substr($_s,0,3) == '"".') {                                                                                                                                                                                                                                                                                                                                                                  
               2 :                                                       $this->_retvalue = substr($_s,3);                                                                                                                                                                                                                                                                                                                                                              
               2 :                                                     } else {                                                                                                                                                                                                                                                                                                                                                                                         
              53 :                                                       $this->_retvalue = $_s;                                                                                                                                                                                                                                                                                                                                                                        
                 :                                                     }                                                                                                                                                                                                                                                                                                                                                                                                
              55 :                                                       }                                                                                                                                                                                                                                                                                                                                                                                              
                 : #line 2319 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 337 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r82(){ $this->_retvalue = "''";     }                                                                                                                                                                                                                                                                                                                                                                                                
                 : #line 2322 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 339 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r83(){ $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor.'::'.$this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                                                               
                 : #line 2325 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 340 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r84(){ $this->prefix_number++; $this->compiler->prefix_code[] = '<?php $_tmp'.$this->prefix_number.'=$_smarty_tpl->getVariable(\''. $this->yystack[$this->yyidx + -3]->minor .'\')->value;?>'; $this->_retvalue = $this->yystack[$this->yyidx + -6]->minor.'::$_tmp'.$this->prefix_number.'('. $this->yystack[$this->yyidx + -1]->minor .')';     }                                                                                  
                 : #line 2328 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 342 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r85(){ $this->_retvalue = $this->yystack[$this->yyidx + -3]->minor.'::'.$this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                      
                 : #line 2331 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 343 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r86(){ $this->prefix_number++; $this->compiler->prefix_code[] = '<?php $_tmp'.$this->prefix_number.'=$_smarty_tpl->getVariable(\''. $this->yystack[$this->yyidx + -4]->minor .'\')->value;?>'; $this->_retvalue = $this->yystack[$this->yyidx + -7]->minor.'::$_tmp'.$this->prefix_number.'('. $this->yystack[$this->yyidx + -2]->minor .')'.$this->yystack[$this->yyidx + 0]->minor;     }                                          
                 : #line 2334 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 345 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r87(){ $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor.'::'.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                
                 : #line 2337 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 347 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r88(){ $this->_retvalue = $this->yystack[$this->yyidx + -4]->minor.'::$'.$this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                      
                 : #line 2340 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 349 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r89(){ $this->_retvalue = $this->yystack[$this->yyidx + -5]->minor.'::$'.$this->yystack[$this->yyidx + -2]->minor.$this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                             
                 : #line 2343 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 351 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r90(){ $this->prefix_number++; $this->compiler->prefix_code[] = '<?php ob_start();?>'.$this->yystack[$this->yyidx + 0]->minor.'<?php $_tmp'.$this->prefix_number.'=ob_get_clean();?>'; $this->_retvalue = '$_tmp'.$this->prefix_number;     }                                                                                                                                                                                        
                 : #line 2346 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 360 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             212 :     function yy_r91(){if ($this->yystack[$this->yyidx + 0]->minor['var'] == '\'smarty\'') { $this->_retvalue =  $this->compiler->compileTag('special_smarty_variable',$this->yystack[$this->yyidx + 0]->minor['index']);} else {                                                                                                                                                                                                                     
             212 :                                                          $this->_retvalue = '$_smarty_tpl->getVariable('. $this->yystack[$this->yyidx + 0]->minor['var'] .')->value'.$this->yystack[$this->yyidx + 0]->minor['index']; $this->compiler->tag_nocache=$this->compiler->tag_nocache|$this->template->getVariable(trim($this->yystack[$this->yyidx + 0]->minor['var'],"'"), null, true, false)->nocache;}    }                                           
                 : #line 2350 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 363 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              12 :     function yy_r92(){ $this->_retvalue = '$_smarty_tpl->getVariable('. $this->yystack[$this->yyidx + -2]->minor .')->'.$this->yystack[$this->yyidx + 0]->minor; $this->compiler->tag_nocache=$this->compiler->tag_nocache|$this->template->getVariable(trim($this->yystack[$this->yyidx + -2]->minor,"'"), null, true, false)->nocache;    }                                                                                                        
                 : #line 2353 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 367 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              17 :     function yy_r94(){$this->_retvalue = '$_smarty_tpl->getConfigVariable(\''. $this->yystack[$this->yyidx + -1]->minor .'\')';    }                                                                                                                                                                                                                                                                                                                 
                 : #line 2356 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 368 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r95(){$this->_retvalue = '$_smarty_tpl->getConfigVariable('. $this->yystack[$this->yyidx + -1]->minor .')';    }                                                                                                                                                                                                                                                                                                                     
                 : #line 2359 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 371 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             215 :     function yy_r96(){$this->_retvalue = array('var'=>$this->yystack[$this->yyidx + -1]->minor, 'index'=>$this->yystack[$this->yyidx + 0]->minor);    }                                                                                                                                                                                                                                                                                              
                 : #line 2362 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 377 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              58 :     function yy_r97(){$this->_retvalue = $this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                      
                 : #line 2365 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 379 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             223 :     function yy_r98(){return;    }                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : #line 2368 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 383 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r99(){ $this->_retvalue = '[$_smarty_tpl->getVariable('. $this->yystack[$this->yyidx + 0]->minor .')->value]'; $this->compiler->tag_nocache=$this->compiler->tag_nocache|$this->template->getVariable('$this->yystack[$this->yyidx + 0]->minor', null, true, false)->nocache;    }                                                                                                                                                   
                 : #line 2371 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 384 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r100(){ $this->_retvalue = '[$_smarty_tpl->getVariable('. $this->yystack[$this->yyidx + -2]->minor .')->'.$this->yystack[$this->yyidx + 0]->minor.']'; $this->compiler->tag_nocache=$this->compiler->tag_nocache|$this->template->getVariable(trim($this->yystack[$this->yyidx + -2]->minor,"'"), null, true, false)->nocache;    }                                                                                                  
                 : #line 2374 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 387 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              10 :     function yy_r101(){ $this->_retvalue = "['". $this->yystack[$this->yyidx + 0]->minor ."']";    }                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2377 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 391 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              10 :     function yy_r104(){ $this->_retvalue = "[". $this->yystack[$this->yyidx + 0]->minor ."]";    }                                                                                                                                                                                                                                                                                                                                                   
                 : #line 2380 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 392 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              24 :     function yy_r105(){ $this->_retvalue = "[". $this->yystack[$this->yyidx + -1]->minor ."]";    }                                                                                                                                                                                                                                                                                                                                                  
                 : #line 2383 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 394 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               5 :     function yy_r106(){ $this->_retvalue = '['.$this->compiler->compileTag('special_smarty_variable','[\'section\'][\''.$this->yystack[$this->yyidx + -1]->minor.'\'][\'index\']').']';    }                                                                                                                                                                                                                                                         
                 : #line 2386 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 395 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r107(){ $this->_retvalue = '['.$this->compiler->compileTag('special_smarty_variable','[\'section\'][\''.$this->yystack[$this->yyidx + -3]->minor.'\'][\''.$this->yystack[$this->yyidx + -1]->minor.'\']').']';    }                                                                                                                                                                                                                  
                 : #line 2389 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 399 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               9 :     function yy_r109(){$this->_retvalue = '';    }                                                                                                                                                                                                                                                                                                                                                                                                   
                 : #line 2392 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 407 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               4 :     function yy_r111(){$this->_retvalue = $this->yystack[$this->yyidx + -1]->minor.'.'.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                 
                 : #line 2395 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 409 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
             217 :     function yy_r112(){$this->_retvalue = '\''.$this->yystack[$this->yyidx + 0]->minor.'\'';    }                                                                                                                                                                                                                                                                                                                                                    
                 : #line 2398 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 412 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               9 :     function yy_r113(){$this->_retvalue = '('.$this->yystack[$this->yyidx + -1]->minor.')';    }                                                                                                                                                                                                                                                                                                                                                     
                 : #line 2401 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 417 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r114(){ if ($this->yystack[$this->yyidx + -1]->minor['var'] == '\'smarty\'') { $this->_retvalue =  $this->compiler->compileTag('special_smarty_variable',$this->yystack[$this->yyidx + -1]->minor['index']).$this->yystack[$this->yyidx + 0]->minor;} else {                                                                                                                                                                         
               3 :                                                          $this->_retvalue = '$_smarty_tpl->getVariable('. $this->yystack[$this->yyidx + -1]->minor['var'] .')->value'.$this->yystack[$this->yyidx + -1]->minor['index'].$this->yystack[$this->yyidx + 0]->minor; $this->compiler->tag_nocache=$this->compiler->tag_nocache|$this->template->getVariable(trim($this->yystack[$this->yyidx + -1]->minor['var'],"'"), null, true, false)->nocache;}    }
                 : #line 2405 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 420 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r115(){$this->_retvalue  = $this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                                                                                                            
                 : #line 2408 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 422 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r116(){$this->_retvalue  = $this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                                                                   
                 : #line 2411 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 424 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r117(){ $this->_retvalue = '->'.$this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                               
                 : #line 2414 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 425 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r118(){ $this->_retvalue = '->{'.$this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor.'}';    }                                                                                                                                                                                                                                                                                                          
                 : #line 2417 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 426 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r119(){ $this->_retvalue = '->{'.$this->yystack[$this->yyidx + -2]->minor.$this->yystack[$this->yyidx + 0]->minor.'}';    }                                                                                                                                                                                                                                                                                                          
                 : #line 2420 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 427 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r120(){ $this->_retvalue = '->{\''.$this->yystack[$this->yyidx + -4]->minor.'\'.'.$this->yystack[$this->yyidx + -2]->minor.$this->yystack[$this->yyidx + 0]->minor.'}';    }                                                                                                                                                                                                                                                         
                 : #line 2423 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 429 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r121(){ $this->_retvalue = '->'.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                                                        
                 : #line 2426 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 435 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              11 :     function yy_r122(){if (!$this->template->security || $this->smarty->security_handler->isTrustedPhpFunction($this->yystack[$this->yyidx + -3]->minor, $this->compiler)) {                                                                                                                                                                                                                                                                         
               9 :                                                                                                 if ($this->yystack[$this->yyidx + -3]->minor == 'isset' || $this->yystack[$this->yyidx + -3]->minor == 'empty' || $this->yystack[$this->yyidx + -3]->minor == 'array' || is_callable($this->yystack[$this->yyidx + -3]->minor)) {                                                                                                                    
               9 :                                                                                                     $this->_retvalue = $this->yystack[$this->yyidx + -3]->minor . "(". $this->yystack[$this->yyidx + -1]->minor .")";                                                                                                                                                                                                                                
               9 :                                                                                                 } else {                                                                                                                                                                                                                                                                                                                                             
               0 :                                                        $this->compiler->trigger_template_error ("unknown function \"" . $this->yystack[$this->yyidx + -3]->minor . "\"");                                                                                                                                                                                                                                                                            
                 :                                                       }                                                                                                                                                                                                                                                                                                                                                                                              
               9 :                                                     }    }                                                                                                                                                                                                                                                                                                                                                                                           
                 : #line 2435 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 446 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r123(){ $this->_retvalue = $this->yystack[$this->yyidx + -3]->minor . "(". $this->yystack[$this->yyidx + -1]->minor .")";    }                                                                                                                                                                                                                                                                                                       
                 : #line 2438 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 450 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r124(){ $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor.",".$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                
                 : #line 2441 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 454 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r126(){ return;    }                                                                                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2444 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 459 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r127(){ $this->_retvalue =  array($this->yystack[$this->yyidx + 0]->minor,'false');    }                                                                                                                                                                                                                                                                                                                                             
                 : #line 2447 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 460 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              14 :     function yy_r128(){ $this->_retvalue =  array($this->yystack[$this->yyidx + 0]->minor,'true');    }                                                                                                                                                                                                                                                                                                                                              
                 : #line 2450 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 476 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               8 :     function yy_r131(){$this->_retvalue = ','.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                                                          
                 : #line 2453 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 477 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r132(){$this->_retvalue = ',\''.$this->yystack[$this->yyidx + 0]->minor.'\'';    }                                                                                                                                                                                                                                                                                                                                                   
                 : #line 2456 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 484 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r134(){$this->_retvalue = '!'.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                                                          
                 : #line 2459 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 489 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              29 :     function yy_r136(){$this->_retvalue =$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                                                                               
                 : #line 2462 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 491 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              66 :     function yy_r137(){$this->_retvalue = $this->yystack[$this->yyidx + -2]->minor.$this->yystack[$this->yyidx + -1]->minor.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                            
                 : #line 2465 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 492 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r138(){$this->_retvalue = 'in_array('.$this->yystack[$this->yyidx + -2]->minor.','.$this->yystack[$this->yyidx + 0]->minor.')';    }                                                                                                                                                                                                                                                                                                 
                 : #line 2468 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 493 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r139(){$this->_retvalue = 'in_array('.$this->yystack[$this->yyidx + -2]->minor.',(array)'.$this->yystack[$this->yyidx + 0]->minor.')';    }                                                                                                                                                                                                                                                                                          
                 : #line 2471 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 495 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r141(){$this->_retvalue = '!('.$this->yystack[$this->yyidx + -2]->minor.' % '.$this->yystack[$this->yyidx + 0]->minor.')';    }                                                                                                                                                                                                                                                                                                      
                 : #line 2474 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 496 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r142(){$this->_retvalue = '('.$this->yystack[$this->yyidx + -2]->minor.' % '.$this->yystack[$this->yyidx + 0]->minor.')';    }                                                                                                                                                                                                                                                                                                       
                 : #line 2477 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 497 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r143(){$this->_retvalue = '!(1 & '.$this->yystack[$this->yyidx + -1]->minor.')';    }                                                                                                                                                                                                                                                                                                                                                
                 : #line 2480 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 498 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r144(){$this->_retvalue = '(1 & '.$this->yystack[$this->yyidx + -1]->minor.')';    }                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2483 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 499 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r145(){$this->_retvalue = '!(1 & '.$this->yystack[$this->yyidx + -2]->minor.' / '.$this->yystack[$this->yyidx + 0]->minor.')';    }                                                                                                                                                                                                                                                                                                  
                 : #line 2486 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 500 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r146(){$this->_retvalue = '(1 & '.$this->yystack[$this->yyidx + -2]->minor.' / '.$this->yystack[$this->yyidx + 0]->minor.')';    }                                                                                                                                                                                                                                                                                                   
                 : #line 2489 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 506 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r152(){$this->prefix_number++; $this->compiler->prefix_code[] = '<?php $_tmp'.$this->prefix_number.'='.$this->yystack[$this->yyidx + 0]->minor.';?>'; $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor.$this->yystack[$this->yyidx + -1]->minor.'$_tmp'.$this->prefix_number;    }                                                                                                                                        
                 : #line 2492 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 508 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               8 :     function yy_r153(){$this->_retvalue = '==';    }                                                                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2495 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 509 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               4 :     function yy_r154(){$this->_retvalue = '!=';    }                                                                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2498 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 510 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              13 :     function yy_r155(){$this->_retvalue = '>';    }                                                                                                                                                                                                                                                                                                                                                                                                  
                 : #line 2501 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 511 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              26 :     function yy_r156(){$this->_retvalue = '<';    }                                                                                                                                                                                                                                                                                                                                                                                                  
                 : #line 2504 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 512 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               7 :     function yy_r157(){$this->_retvalue = '>=';    }                                                                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2507 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 513 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               4 :     function yy_r158(){$this->_retvalue = '<=';    }                                                                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2510 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 514 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               9 :     function yy_r159(){$this->_retvalue = '===';    }                                                                                                                                                                                                                                                                                                                                                                                                
                 : #line 2513 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 515 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r160(){$this->_retvalue = '!==';    }                                                                                                                                                                                                                                                                                                                                                                                                
                 : #line 2516 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 516 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r161(){$this->_retvalue = '%';    }                                                                                                                                                                                                                                                                                                                                                                                                  
                 : #line 2519 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 518 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               5 :     function yy_r162(){$this->_retvalue = '&&';    }                                                                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2522 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 519 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               5 :     function yy_r163(){$this->_retvalue = '||';    }                                                                                                                                                                                                                                                                                                                                                                                                 
                 : #line 2525 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 520 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r164(){$this->_retvalue = ' XOR ';    }                                                                                                                                                                                                                                                                                                                                                                                              
                 : #line 2528 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 525 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              42 :     function yy_r165(){ $this->_retvalue = 'array('.$this->yystack[$this->yyidx + -1]->minor.')';    }                                                                                                                                                                                                                                                                                                                                               
                 : #line 2531 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 527 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
              42 :     function yy_r167(){ $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor.','.$this->yystack[$this->yyidx + 0]->minor;     }                                                                                                                                                                                                                                                                                                               
                 : #line 2534 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 528 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :     function yy_r168(){ return;     }                                                                                                                                                                                                                                                                                                                                                                                                                
                 : #line 2537 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 529 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r169(){ $this->_retvalue = $this->yystack[$this->yyidx + -2]->minor.'=>'.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                               
                 : #line 2540 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 530 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r170(){ $this->_retvalue = '\''.$this->yystack[$this->yyidx + -2]->minor.'\'=>'.$this->yystack[$this->yyidx + 0]->minor;    }                                                                                                                                                                                                                                                                                                        
                 : #line 2543 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 539 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               8 :     function yy_r174(){$this->_retvalue = '".'.$this->yystack[$this->yyidx + -1]->minor.'."'; $this->compiler->has_variable_string = true;    }                                                                                                                                                                                                                                                                                                      
                 : #line 2546 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 540 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               3 :     function yy_r175(){$this->_retvalue = '".'.'$_smarty_tpl->getVariable(\''. substr($this->yystack[$this->yyidx + 0]->minor,1) .'\')->value'.'."'; $this->compiler->tag_nocache=$this->compiler->tag_nocache|$this->template->getVariable(trim($this->yystack[$this->yyidx + 0]->minor,"'"), null, true, false)->nocache; $this->compiler->has_variable_string = true;    }                                                                        
                 : #line 2549 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 542 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               1 :     function yy_r177(){ $this->_retvalue = '".('.$this->yystack[$this->yyidx + -1]->minor.')."'; $this->compiler->has_variable_string = true;    }                                                                                                                                                                                                                                                                                                   
                 : #line 2552 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 : #line 543 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                         
               2 :     function yy_r178(){ $this->prefix_number++; $this->compiler->prefix_code[] = '<?php ob_start();?>'.$this->yystack[$this->yyidx + 0]->minor.'<?php $_tmp'.$this->prefix_number.'=ob_get_clean();?>'; $this->_retvalue = '".$_tmp'.$this->prefix_number.'."'; $this->compiler->has_variable_string = true;    }                                                                                                                                    
                 : #line 2555 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * placeholder for the left hand side in a reduce operation.                                                                                                                                                                                                                                                                                                                                                                                     
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * For a parser with a rule like this:                                                                                                                                                                                                                                                                                                                                                                                                           
                 :      * <pre>                                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :      * rule(A) ::= B. { A = 1; }                                                                                                                                                                                                                                                                                                                                                                                                                     
                 :      * </pre>                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * The parser will translate to something like:                                                                                                                                                                                                                                                                                                                                                                                                  
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * <code>                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      * function yy_r0(){$this->_retvalue = 1;}                                                                                                                                                                                                                                                                                                                                                                                                       
                 :      * </code>                                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     private $_retvalue;                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * Perform a reduce action and the shift that must immediately                                                                                                                                                                                                                                                                                                                                                                                   
                 :      * follow the reduce.                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * For a rule such as:                                                                                                                                                                                                                                                                                                                                                                                                                           
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * <pre>                                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :      * A ::= B blah C. { dosomething(); }                                                                                                                                                                                                                                                                                                                                                                                                            
                 :      * </pre>                                                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * This function will first call the action, if any, ("dosomething();" in our                                                                                                                                                                                                                                                                                                                                                                    
                 :      * example), and then it will pop three states from the stack,                                                                                                                                                                                                                                                                                                                                                                                   
                 :      * one for each entry on the right-hand side of the expression                                                                                                                                                                                                                                                                                                                                                                                   
                 :      * (B, blah, and C in our example rule), and then push the result of the action                                                                                                                                                                                                                                                                                                                                                                  
                 :      * back on to the stack with the resulting state reduced to (as described in the .out                                                                                                                                                                                                                                                                                                                                                            
                 :      * file)                                                                                                                                                                                                                                                                                                                                                                                                                                         
                 :      * @param int Number of the rule by which to reduce                                                                                                                                                                                                                                                                                                                                                                                              
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_reduce($yyruleno)                                                                                                                                                                                                                                                                                                                                                                                                                    
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :         //int $yygoto;                     /* The next state */                                                                                                                                                                                                                                                                                                                                                                                      
                 :         //int $yyact;                      /* The next action */                                                                                                                                                                                                                                                                                                                                                                                     
                 :         //mixed $yygotominor;        /* The LHS of the rule reduced */                                                                                                                                                                                                                                                                                                                                                                               
                 :         //TP_yyStackEntry $yymsp;            /* The top of the parser's stack */                                                                                                                                                                                                                                                                                                                                                                     
                 :         //int $yysize;                     /* Amount to pop the stack */                                                                                                                                                                                                                                                                                                                                                                             
             402 :         $yymsp = $this->yystack[$this->yyidx];                                                                                                                                                                                                                                                                                                                                                                                                       
             402 :         if (self::$yyTraceFILE && $yyruleno >= 0                                                                                                                                                                                                                                                                                                                                                                                                     
             402 :               && $yyruleno < count(self::$yyRuleName)) {                                                                                                                                                                                                                                                                                                                                                                                             
               0 :             fprintf(self::$yyTraceFILE, "%sReduce (%d) [%s].\n",                                                                                                                                                                                                                                                                                                                                                                                     
               0 :                 self::$yyTracePrompt, $yyruleno,                                                                                                                                                                                                                                                                                                                                                                                                     
               0 :                 self::$yyRuleName[$yyruleno]);                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
             402 :         $this->_retvalue = $yy_lefthand_side = null;                                                                                                                                                                                                                                                                                                                                                                                                 
             402 :         if (array_key_exists($yyruleno, self::$yyReduceMap)) {                                                                                                                                                                                                                                                                                                                                                                                       
                 :             // call the action                                                                                                                                                                                                                                                                                                                                                                                                                       
             402 :             $this->_retvalue = null;                                                                                                                                                                                                                                                                                                                                                                                                                 
             402 :             $this->{'yy_r' . self::$yyReduceMap[$yyruleno]}();                                                                                                                                                                                                                                                                                                                                                                                       
             399 :             $yy_lefthand_side = $this->_retvalue;                                                                                                                                                                                                                                                                                                                                                                                                    
             399 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             399 :         $yygoto = self::$yyRuleInfo[$yyruleno]['lhs'];                                                                                                                                                                                                                                                                                                                                                                                               
             399 :         $yysize = self::$yyRuleInfo[$yyruleno]['rhs'];                                                                                                                                                                                                                                                                                                                                                                                               
             399 :         $this->yyidx -= $yysize;                                                                                                                                                                                                                                                                                                                                                                                                                     
             399 :         for($i = $yysize; $i; $i--) {                                                                                                                                                                                                                                                                                                                                                                                                                
                 :             // pop all of the right-hand side parameters                                                                                                                                                                                                                                                                                                                                                                                             
             398 :             array_pop($this->yystack);                                                                                                                                                                                                                                                                                                                                                                                                               
             398 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             399 :         $yyact = $this->yy_find_reduce_action($this->yystack[$this->yyidx]->stateno, $yygoto);                                                                                                                                                                                                                                                                                                                                                       
             399 :         if ($yyact < self::YYNSTATE) {                                                                                                                                                                                                                                                                                                                                                                                                               
                 :             /* If we are not debugging and the reduce action popped at least                                                                                                                                                                                                                                                                                                                                                                         
                 :             ** one element off the stack, then we can push the new element back                                                                                                                                                                                                                                                                                                                                                                      
                 :             ** onto the stack here, and skip the stack overflow test in yy_shift().                                                                                                                                                                                                                                                                                                                                                                  
                 :             ** That gives a significant speed improvement. */                                                                                                                                                                                                                                                                                                                                                                                        
             399 :             if (!self::$yyTraceFILE && $yysize) {                                                                                                                                                                                                                                                                                                                                                                                                    
             398 :                 $this->yyidx++;                                                                                                                                                                                                                                                                                                                                                                                                                      
             398 :                 $x = new TP_yyStackEntry;                                                                                                                                                                                                                                                                                                                                                                                                            
             398 :                 $x->stateno = $yyact;                                                                                                                                                                                                                                                                                                                                                                                                                
             398 :                 $x->major = $yygoto;                                                                                                                                                                                                                                                                                                                                                                                                                 
             398 :                 $x->minor = $yy_lefthand_side;                                                                                                                                                                                                                                                                                                                                                                                                       
             398 :                 $this->yystack[$this->yyidx] = $x;                                                                                                                                                                                                                                                                                                                                                                                                   
             398 :             } else {                                                                                                                                                                                                                                                                                                                                                                                                                                 
             247 :                 $this->yy_shift($yyact, $yygoto, $yy_lefthand_side);                                                                                                                                                                                                                                                                                                                                                                                 
                 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
             399 :         } elseif ($yyact == self::YYNSTATE + self::YYNRULE + 1) {                                                                                                                                                                                                                                                                                                                                                                                    
             391 :             $this->yy_accept();                                                                                                                                                                                                                                                                                                                                                                                                                      
             391 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             399 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * The following code executes when the parse fails                                                                                                                                                                                                                                                                                                                                                                                              
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * Code from %parse_fail is inserted here                                                                                                                                                                                                                                                                                                                                                                                                        
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_parse_failed()                                                                                                                                                                                                                                                                                                                                                                                                                       
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :         if (self::$yyTraceFILE) {                                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :             fprintf(self::$yyTraceFILE, "%sFail!\n", self::$yyTracePrompt);                                                                                                                                                                                                                                                                                                                                                                          
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :         while ($this->yyidx >= 0) {                                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :             $this->yy_pop_parser_stack();                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :         /* Here code is inserted which will be executed whenever the                                                                                                                                                                                                                                                                                                                                                                                 
                 :         ** parser fails */                                                                                                                                                                                                                                                                                                                                                                                                                           
               0 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * The following code executes when a syntax error first occurs.                                                                                                                                                                                                                                                                                                                                                                                 
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * %syntax_error code is inserted here                                                                                                                                                                                                                                                                                                                                                                                                           
                 :      * @param int The major type of the error token                                                                                                                                                                                                                                                                                                                                                                                                  
                 :      * @param mixed The minor type of the error token                                                                                                                                                                                                                                                                                                                                                                                                
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_syntax_error($yymajor, $TOKEN)                                                                                                                                                                                                                                                                                                                                                                                                       
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 : #line 60 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
               1 :     $this->internalError = true;                                                                                                                                                                                                                                                                                                                                                                                                                     
               1 :     $this->yymajor = $yymajor;                                                                                                                                                                                                                                                                                                                                                                                                                       
               1 :     $this->compiler->trigger_template_error();                                                                                                                                                                                                                                                                                                                                                                                                       
                 : #line 2673 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
               0 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * The following is executed when the parser accepts                                                                                                                                                                                                                                                                                                                                                                                             
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * %parse_accept code is inserted here                                                                                                                                                                                                                                                                                                                                                                                                           
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function yy_accept()                                                                                                                                                                                                                                                                                                                                                                                                                             
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
             391 :         if (self::$yyTraceFILE) {                                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :             fprintf(self::$yyTraceFILE, "%sAccept!\n", self::$yyTracePrompt);                                                                                                                                                                                                                                                                                                                                                                        
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             391 :         while ($this->yyidx >= 0) {                                                                                                                                                                                                                                                                                                                                                                                                                  
             391 :             $stack = $this->yy_pop_parser_stack();                                                                                                                                                                                                                                                                                                                                                                                                   
             391 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :         /* Here code is inserted which will be executed whenever the                                                                                                                                                                                                                                                                                                                                                                                 
                 :         ** parser accepts */                                                                                                                                                                                                                                                                                                                                                                                                                         
                 : #line 52 "smarty_internal_templateparser.y"                                                                                                                                                                                                                                                                                                                                                                                                          
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
             391 :     $this->successful = !$this->internalError;                                                                                                                                                                                                                                                                                                                                                                                                       
             391 :     $this->internalError = false;                                                                                                                                                                                                                                                                                                                                                                                                                    
             391 :     $this->retvalue = $this->_retvalue;                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     //echo $this->retvalue."\n\n";                                                                                                                                                                                                                                                                                                                                                                                                                   
                 : #line 2698 "smarty_internal_templateparser.php"                                                                                                                                                                                                                                                                                                                                                                                                      
             391 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :     /**                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :      * The main parser program.                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * The first argument is the major token number.  The second is                                                                                                                                                                                                                                                                                                                                                                                  
                 :      * the token value string as scanned from the input.                                                                                                                                                                                                                                                                                                                                                                                             
                 :      *                                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :      * @param int the token number                                                                                                                                                                                                                                                                                                                                                                                                                   
                 :      * @param mixed the token value                                                                                                                                                                                                                                                                                                                                                                                                                  
                 :      * @param mixed any extra arguments that should be passed to handlers                                                                                                                                                                                                                                                                                                                                                                            
                 :      */                                                                                                                                                                                                                                                                                                                                                                                                                                              
                 :     function doParse($yymajor, $yytokenvalue)                                                                                                                                                                                                                                                                                                                                                                                                        
                 :     {                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 : //        $yyact;            /* The parser action. */                                                                                                                                                                                                                                                                                                                                                                                                
                 : //        $yyendofinput;     /* True if we are at the end of input */                                                                                                                                                                                                                                                                                                                                                                                
             403 :         $yyerrorhit = 0;   /* True if yymajor has invoked an error */                                                                                                                                                                                                                                                                                                                                                                                
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         /* (re)initialize the parser, if necessary */                                                                                                                                                                                                                                                                                                                                                                                                
             403 :         if ($this->yyidx === null || $this->yyidx < 0) {                                                                                                                                                                                                                                                                                                                                                                                             
                 :             /* if ($yymajor == 0) return; // not sure why this was here... */                                                                                                                                                                                                                                                                                                                                                                        
             403 :             $this->yyidx = 0;                                                                                                                                                                                                                                                                                                                                                                                                                        
             403 :             $this->yyerrcnt = -1;                                                                                                                                                                                                                                                                                                                                                                                                                    
             403 :             $x = new TP_yyStackEntry;                                                                                                                                                                                                                                                                                                                                                                                                                
             403 :             $x->stateno = 0;                                                                                                                                                                                                                                                                                                                                                                                                                         
             403 :             $x->major = 0;                                                                                                                                                                                                                                                                                                                                                                                                                           
             403 :             $this->yystack = array();                                                                                                                                                                                                                                                                                                                                                                                                                
             403 :             array_push($this->yystack, $x);                                                                                                                                                                                                                                                                                                                                                                                                          
             403 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
             403 :         $yyendofinput = ($yymajor==0);                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
             403 :         if (self::$yyTraceFILE) {                                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :             fprintf(self::$yyTraceFILE, "%sInput %s\n",                                                                                                                                                                                                                                                                                                                                                                                              
               0 :                 self::$yyTracePrompt, $this->yyTokenName[$yymajor]);                                                                                                                                                                                                                                                                                                                                                                                 
               0 :         }                                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                 :         do {                                                                                                                                                                                                                                                                                                                                                                                                                                         
             403 :             $yyact = $this->yy_find_shift_action($yymajor);                                                                                                                                                                                                                                                                                                                                                                                          
             403 :             if ($yymajor < self::YYERRORSYMBOL &&                                                                                                                                                                                                                                                                                                                                                                                                    
             403 :                   !$this->yy_is_expected_token($yymajor)) {                                                                                                                                                                                                                                                                                                                                                                                          
                 :                 // force a syntax error                                                                                                                                                                                                                                                                                                                                                                                                              
               0 :                 $yyact = self::YY_ERROR_ACTION;                                                                                                                                                                                                                                                                                                                                                                                                      
               0 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
             403 :             if ($yyact < self::YYNSTATE) {                                                                                                                                                                                                                                                                                                                                                                                                           
             403 :                 $this->yy_shift($yyact, $yymajor, $yytokenvalue);                                                                                                                                                                                                                                                                                                                                                                                    
             403 :                 $this->yyerrcnt--;                                                                                                                                                                                                                                                                                                                                                                                                                   
             403 :                 if ($yyendofinput && $this->yyidx >= 0) {                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                     $yymajor = 0;                                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :                 } else {                                                                                                                                                                                                                                                                                                                                                                                                                             
             403 :                     $yymajor = self::YYNOCODE;                                                                                                                                                                                                                                                                                                                                                                                                       
                 :                 }                                                                                                                                                                                                                                                                                                                                                                                                                                    
             403 :             } elseif ($yyact < self::YYNSTATE + self::YYNRULE) {                                                                                                                                                                                                                                                                                                                                                                                     
             402 :                 $this->yy_reduce($yyact - self::YYNSTATE);                                                                                                                                                                                                                                                                                                                                                                                           
             400 :             } elseif ($yyact == self::YY_ERROR_ACTION) {                                                                                                                                                                                                                                                                                                                                                                                             
               1 :                 if (self::$yyTraceFILE) {                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                     fprintf(self::$yyTraceFILE, "%sSyntax Error!\n",                                                                                                                                                                                                                                                                                                                                                                                 
               0 :                         self::$yyTracePrompt);                                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                 }                                                                                                                                                                                                                                                                                                                                                                                                                                    
               1 :                 if (self::YYERRORSYMBOL) {                                                                                                                                                                                                                                                                                                                                                                                                           
                 :                     /* A syntax error has occurred.                                                                                                                                                                                                                                                                                                                                                                                                  
                 :                     ** The response to an error depends upon whether or not the                                                                                                                                                                                                                                                                                                                                                                      
                 :                     ** grammar defines an error token "ERROR".                                                                                                                                                                                                                                                                                                                                                                                       
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     ** This is what we do if the grammar does define ERROR:                                                                                                                                                                                                                                                                                                                                                                          
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     **  * Call the %syntax_error function.                                                                                                                                                                                                                                                                                                                                                                                           
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     **  * Begin popping the stack until we enter a state where                                                                                                                                                                                                                                                                                                                                                                       
                 :                     **    it is legal to shift the error symbol, then shift                                                                                                                                                                                                                                                                                                                                                                          
                 :                     **    the error symbol.                                                                                                                                                                                                                                                                                                                                                                                                          
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     **  * Set the error count to three.                                                                                                                                                                                                                                                                                                                                                                                              
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     **  * Begin accepting and shifting new tokens.  No new error                                                                                                                                                                                                                                                                                                                                                                     
                 :                     **    processing will occur until three tokens have been                                                                                                                                                                                                                                                                                                                                                                         
                 :                     **    shifted successfully.                                                                                                                                                                                                                                                                                                                                                                                                      
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     */                                                                                                                                                                                                                                                                                                                                                                                                                               
               1 :                     if ($this->yyerrcnt < 0) {                                                                                                                                                                                                                                                                                                                                                                                                       
               1 :                         $this->yy_syntax_error($yymajor, $yytokenvalue);                                                                                                                                                                                                                                                                                                                                                                             
               0 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                     $yymx = $this->yystack[$this->yyidx]->major;                                                                                                                                                                                                                                                                                                                                                                                     
               0 :                     if ($yymx == self::YYERRORSYMBOL || $yyerrorhit ){                                                                                                                                                                                                                                                                                                                                                                               
               0 :                         if (self::$yyTraceFILE) {                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :                             fprintf(self::$yyTraceFILE, "%sDiscard input token %s\n",                                                                                                                                                                                                                                                                                                                                                                
               0 :                                 self::$yyTracePrompt, $this->yyTokenName[$yymajor]);                                                                                                                                                                                                                                                                                                                                                                 
               0 :                         }                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                         $this->yy_destructor($yymajor, $yytokenvalue);                                                                                                                                                                                                                                                                                                                                                                               
               0 :                         $yymajor = self::YYNOCODE;                                                                                                                                                                                                                                                                                                                                                                                                   
               0 :                     } else {                                                                                                                                                                                                                                                                                                                                                                                                                         
               0 :                         while ($this->yyidx >= 0 &&                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :                                  $yymx != self::YYERRORSYMBOL &&                                                                                                                                                                                                                                                                                                                                                                                     
               0 :         ($yyact = $this->yy_find_shift_action(self::YYERRORSYMBOL)) >= self::YYNSTATE                                                                                                                                                                                                                                                                                                                                                                
               0 :                               ){                                                                                                                                                                                                                                                                                                                                                                                                                     
               0 :                             $this->yy_pop_parser_stack();                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                         }                                                                                                                                                                                                                                                                                                                                                                                                                            
               0 :                         if ($this->yyidx < 0 || $yymajor==0) {                                                                                                                                                                                                                                                                                                                                                                                       
               0 :                             $this->yy_destructor($yymajor, $yytokenvalue);                                                                                                                                                                                                                                                                                                                                                                           
               0 :                             $this->yy_parse_failed();                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                             $yymajor = self::YYNOCODE;                                                                                                                                                                                                                                                                                                                                                                                               
               0 :                         } elseif ($yymx != self::YYERRORSYMBOL) {                                                                                                                                                                                                                                                                                                                                                                                    
               0 :                             $u2 = 0;                                                                                                                                                                                                                                                                                                                                                                                                                 
               0 :                             $this->yy_shift($yyact, self::YYERRORSYMBOL, $u2);                                                                                                                                                                                                                                                                                                                                                                       
               0 :                         }                                                                                                                                                                                                                                                                                                                                                                                                                            
                 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                     $this->yyerrcnt = 3;                                                                                                                                                                                                                                                                                                                                                                                                             
               0 :                     $yyerrorhit = 1;                                                                                                                                                                                                                                                                                                                                                                                                                 
               0 :                 } else {                                                                                                                                                                                                                                                                                                                                                                                                                             
                 :                     /* YYERRORSYMBOL is not defined */                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     /* This is what we do if the grammar does not define ERROR:                                                                                                                                                                                                                                                                                                                                                                      
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     **  * Report an error message, and throw away the input token.                                                                                                                                                                                                                                                                                                                                                                   
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     **  * If the input token is $, then fail the parse.                                                                                                                                                                                                                                                                                                                                                                              
                 :                     **                                                                                                                                                                                                                                                                                                                                                                                                                               
                 :                     ** As before, subsequent error messages are suppressed until                                                                                                                                                                                                                                                                                                                                                                     
                 :                     ** three input tokens have been successfully shifted.                                                                                                                                                                                                                                                                                                                                                                            
                 :                     */                                                                                                                                                                                                                                                                                                                                                                                                                               
               0 :                     if ($this->yyerrcnt <= 0) {                                                                                                                                                                                                                                                                                                                                                                                                      
               0 :                         $this->yy_syntax_error($yymajor, $yytokenvalue);                                                                                                                                                                                                                                                                                                                                                                             
               0 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                     $this->yyerrcnt = 3;                                                                                                                                                                                                                                                                                                                                                                                                             
               0 :                     $this->yy_destructor($yymajor, $yytokenvalue);                                                                                                                                                                                                                                                                                                                                                                                   
               0 :                     if ($yyendofinput) {                                                                                                                                                                                                                                                                                                                                                                                                             
               0 :                         $this->yy_parse_failed();                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :                     }                                                                                                                                                                                                                                                                                                                                                                                                                                
               0 :                     $yymajor = self::YYNOCODE;                                                                                                                                                                                                                                                                                                                                                                                                       
                 :                 }                                                                                                                                                                                                                                                                                                                                                                                                                                    
               0 :             } else {                                                                                                                                                                                                                                                                                                                                                                                                                                 
               0 :                 $this->yy_accept();                                                                                                                                                                                                                                                                                                                                                                                                                  
               0 :                 $yymajor = self::YYNOCODE;                                                                                                                                                                                                                                                                                                                                                                                                           
                 :             }                                                                                                                                                                                                                                                                                                                                                                                                                                        
             403 :         } while ($yymajor != self::YYNOCODE && $this->yyidx >= 0);                                                                                                                                                                                                                                                                                                                                                                                   
             403 :     }                                                                                                                                                                                                                                                                                                                                                                                                                                                
                 : }                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                 : ?>